--- /dev/null
+// $G $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.
+
+// Semi-exhaustive test for append()
+
+package main
+
+import (
+ "fmt"
+ "reflect"
+)
+
+
+func verify(name string, result, expected interface{}) {
+ if !reflect.DeepEqual(result, expected) {
+ panic(name)
+ }
+}
+
+
+func main() {
+ for _, t := range tests {
+ verify(t.name, t.result, t.expected)
+ }
+ verifyStruct()
+ verifyInterface()
+}
+
+
+var tests = []struct {
+ name string
+ result, expected interface{}
+}{
+ {"bool a", append([]bool{}), []bool{}},
+ {"bool b", append([]bool{}, true), []bool{true}},
+ {"bool c", append([]bool{}, true, false, true, true), []bool{true, false, true, true}},
+
+ {"bool d", append([]bool{true, false, true}), []bool{true, false, true}},
+ {"bool e", append([]bool{true, false, true}, false), []bool{true, false, true, false}},
+ {"bool f", append([]bool{true, false, true}, false, false, false), []bool{true, false, true, false, false, false}},
+
+ {"bool g", append([]bool{}, []bool{true}...), []bool{true}},
+ {"bool h", append([]bool{}, []bool{true, false, true, false}...), []bool{true, false, true, false}},
+
+ {"bool i", append([]bool{true, false, true}, []bool{true}...), []bool{true, false, true, true}},
+ {"bool j", append([]bool{true, false, true}, []bool{true, true, true}...), []bool{true, false, true, true, true, true}},
+
+
+ {"byte a", append([]byte{}), []byte{}},
+ {"byte b", append([]byte{}, 0), []byte{0}},
+ {"byte c", append([]byte{}, 0, 1, 2, 3), []byte{0, 1, 2, 3}},
+
+ {"byte d", append([]byte{0, 1, 2}), []byte{0, 1, 2}},
+ {"byte e", append([]byte{0, 1, 2}, 3), []byte{0, 1, 2, 3}},
+ {"byte f", append([]byte{0, 1, 2}, 3, 4, 5), []byte{0, 1, 2, 3, 4, 5}},
+
+ {"byte g", append([]byte{}, []byte{0}...), []byte{0}},
+ {"byte h", append([]byte{}, []byte{0, 1, 2, 3}...), []byte{0, 1, 2, 3}},
+
+ {"byte i", append([]byte{0, 1, 2}, []byte{3}...), []byte{0, 1, 2, 3}},
+ {"byte j", append([]byte{0, 1, 2}, []byte{3, 4, 5}...), []byte{0, 1, 2, 3, 4, 5}},
+
+
+ {"int16 a", append([]int16{}), []int16{}},
+ {"int16 b", append([]int16{}, 0), []int16{0}},
+ {"int16 c", append([]int16{}, 0, 1, 2, 3), []int16{0, 1, 2, 3}},
+
+ {"int16 d", append([]int16{0, 1, 2}), []int16{0, 1, 2}},
+ {"int16 e", append([]int16{0, 1, 2}, 3), []int16{0, 1, 2, 3}},
+ {"int16 f", append([]int16{0, 1, 2}, 3, 4, 5), []int16{0, 1, 2, 3, 4, 5}},
+
+ {"int16 g", append([]int16{}, []int16{0}...), []int16{0}},
+ {"int16 h", append([]int16{}, []int16{0, 1, 2, 3}...), []int16{0, 1, 2, 3}},
+
+ {"int16 i", append([]int16{0, 1, 2}, []int16{3}...), []int16{0, 1, 2, 3}},
+ {"int16 j", append([]int16{0, 1, 2}, []int16{3, 4, 5}...), []int16{0, 1, 2, 3, 4, 5}},
+
+
+ {"uint32 a", append([]uint32{}), []uint32{}},
+ {"uint32 b", append([]uint32{}, 0), []uint32{0}},
+ {"uint32 c", append([]uint32{}, 0, 1, 2, 3), []uint32{0, 1, 2, 3}},
+
+ {"uint32 d", append([]uint32{0, 1, 2}), []uint32{0, 1, 2}},
+ {"uint32 e", append([]uint32{0, 1, 2}, 3), []uint32{0, 1, 2, 3}},
+ {"uint32 f", append([]uint32{0, 1, 2}, 3, 4, 5), []uint32{0, 1, 2, 3, 4, 5}},
+
+ {"uint32 g", append([]uint32{}, []uint32{0}...), []uint32{0}},
+ {"uint32 h", append([]uint32{}, []uint32{0, 1, 2, 3}...), []uint32{0, 1, 2, 3}},
+
+ {"uint32 i", append([]uint32{0, 1, 2}, []uint32{3}...), []uint32{0, 1, 2, 3}},
+ {"uint32 j", append([]uint32{0, 1, 2}, []uint32{3, 4, 5}...), []uint32{0, 1, 2, 3, 4, 5}},
+
+
+ {"float64 a", append([]float64{}), []float64{}},
+ {"float64 b", append([]float64{}, 0), []float64{0}},
+ {"float64 c", append([]float64{}, 0, 1, 2, 3), []float64{0, 1, 2, 3}},
+
+ {"float64 d", append([]float64{0, 1, 2}), []float64{0, 1, 2}},
+ {"float64 e", append([]float64{0, 1, 2}, 3), []float64{0, 1, 2, 3}},
+ {"float64 f", append([]float64{0, 1, 2}, 3, 4, 5), []float64{0, 1, 2, 3, 4, 5}},
+
+ {"float64 g", append([]float64{}, []float64{0}...), []float64{0}},
+ {"float64 h", append([]float64{}, []float64{0, 1, 2, 3}...), []float64{0, 1, 2, 3}},
+
+ {"float64 i", append([]float64{0, 1, 2}, []float64{3}...), []float64{0, 1, 2, 3}},
+ {"float64 j", append([]float64{0, 1, 2}, []float64{3, 4, 5}...), []float64{0, 1, 2, 3, 4, 5}},
+
+
+ {"complex128 a", append([]complex128{}), []complex128{}},
+ {"complex128 b", append([]complex128{}, 0), []complex128{0}},
+ {"complex128 c", append([]complex128{}, 0, 1, 2, 3), []complex128{0, 1, 2, 3}},
+
+ {"complex128 d", append([]complex128{0, 1, 2}), []complex128{0, 1, 2}},
+ {"complex128 e", append([]complex128{0, 1, 2}, 3), []complex128{0, 1, 2, 3}},
+ {"complex128 f", append([]complex128{0, 1, 2}, 3, 4, 5), []complex128{0, 1, 2, 3, 4, 5}},
+
+ {"complex128 g", append([]complex128{}, []complex128{0}...), []complex128{0}},
+ {"complex128 h", append([]complex128{}, []complex128{0, 1, 2, 3}...), []complex128{0, 1, 2, 3}},
+
+ {"complex128 i", append([]complex128{0, 1, 2}, []complex128{3}...), []complex128{0, 1, 2, 3}},
+ {"complex128 j", append([]complex128{0, 1, 2}, []complex128{3, 4, 5}...), []complex128{0, 1, 2, 3, 4, 5}},
+
+
+ {"string a", append([]string{}), []string{}},
+ {"string b", append([]string{}, "0"), []string{"0"}},
+ {"string c", append([]string{}, "0", "1", "2", "3"), []string{"0", "1", "2", "3"}},
+
+ {"string d", append([]string{"0", "1", "2"}), []string{"0", "1", "2"}},
+ {"string e", append([]string{"0", "1", "2"}, "3"), []string{"0", "1", "2", "3"}},
+ {"string f", append([]string{"0", "1", "2"}, "3", "4", "5"), []string{"0", "1", "2", "3", "4", "5"}},
+
+ {"string g", append([]string{}, []string{"0"}...), []string{"0"}},
+ {"string h", append([]string{}, []string{"0", "1", "2", "3"}...), []string{"0", "1", "2", "3"}},
+
+ {"string i", append([]string{"0", "1", "2"}, []string{"3"}...), []string{"0", "1", "2", "3"}},
+ {"string j", append([]string{"0", "1", "2"}, []string{"3", "4", "5"}...), []string{"0", "1", "2", "3", "4", "5"}},
+}
+
+
+func verifyStruct() {
+ type T struct {
+ a, b, c string
+ }
+ type S []T
+ e := make(S, 100)
+ for i := range e {
+ e[i] = T{"foo", fmt.Sprintf("%d", i), "bar"}
+ }
+
+ verify("struct a", append(S{}), S{})
+ verify("struct b", append(S{}, e[0]), e[0:1])
+ verify("struct c", append(S{}, e[0], e[1], e[2]), e[0:3])
+
+ verify("struct d", append(e[0:1]), e[0:1])
+ verify("struct e", append(e[0:1], e[1]), e[0:2])
+ verify("struct f", append(e[0:1], e[1], e[2], e[3]), e[0:4])
+
+ verify("struct g", append(e[0:3]), e[0:3])
+ verify("struct h", append(e[0:3], e[3]), e[0:4])
+ verify("struct i", append(e[0:3], e[3], e[4], e[5], e[6]), e[0:7])
+
+ for i := range e {
+ verify("struct j", append(S{}, e[0:i]...), e[0:i])
+ input := make(S, i)
+ copy(input, e[0:i])
+ verify("struct k", append(input, e[i:]...), e)
+ verify("struct k - input modified", input, e[0:i])
+ }
+
+ s := make(S, 10, 20)
+ r := make(S, len(s)+len(e))
+ for i, x := range e {
+ r[len(s)+i] = x
+ }
+ verify("struct l", append(s), s)
+ verify("struct m", append(s, e...), r)
+}
+
+
+func verifyInterface() {
+ type T interface{}
+ type S []T
+ e := make(S, 100)
+ for i := range e {
+ switch i % 4 {
+ case 0:
+ e[i] = i
+ case 1:
+ e[i] = "foo"
+ case 2:
+ e[i] = fmt.Sprintf("%d", i)
+ case 3:
+ e[i] = float64(i)
+ }
+ }
+
+ verify("interface a", append(S{}), S{})
+ verify("interface b", append(S{}, e[0]), e[0:1])
+ verify("interface c", append(S{}, e[0], e[1], e[2]), e[0:3])
+
+ verify("interface d", append(e[0:1]), e[0:1])
+ verify("interface e", append(e[0:1], e[1]), e[0:2])
+ verify("interface f", append(e[0:1], e[1], e[2], e[3]), e[0:4])
+
+ verify("interface g", append(e[0:3]), e[0:3])
+ verify("interface h", append(e[0:3], e[3]), e[0:4])
+ verify("interface i", append(e[0:3], e[3], e[4], e[5], e[6]), e[0:7])
+
+ for i := range e {
+ verify("interface j", append(S{}, e[0:i]...), e[0:i])
+ input := make(S, i)
+ copy(input, e[0:i])
+ verify("interface k", append(input, e[i:]...), e)
+ verify("interface k - input modified", input, e[0:i])
+ }
+
+ s := make(S, 10, 20)
+ r := make(S, len(s)+len(e))
+ for i, x := range e {
+ r[len(s)+i] = x
+ }
+ verify("interface l", append(s), s)
+ verify("interface m", append(s, e...), r)
+}
+++ /dev/null
-./235.go
-# ./64bit.go # fail, flaky on android build
-./args.go
-./assign.go
-./assign1.go
-./bigalg.go
-./bigmap.go
-./blank.go
-./blank1.go
-./chancap.go
-./char_lit.go
-./char_lit1.go
-./closedchan.go
-./closure.go
-./cmp1.go
-./cmp2.go
-./cmp3.go
-./cmp4.go
-./cmp5.go
-./cmplx.go
-# ./cmplxdivide.go # fail, BUG
-./cmplxdivide1.go
-./complit.go
-./compos.go
-./const.go
-./const1.go
-./const2.go
-./const3.go
-./convert.go
-./convert3.go
-./convlit.go
-./convlit1.go
-./copy.go
-./ddd.go
-./ddd1.go
-./ddd2.go
-./ddd3.go
-./decl.go
-./declbad.go
-./defer.go
-./deferprint.go
-./empty.go
-./env.go
-./escape.go
-./float_lit.go
-./floatcmp.go
-./for.go
-./func.go
-./func1.go
-./func2.go
-./func3.go
-./func4.go
-./func5.go
-./gc.go
-./gc1.go
-./hashmap.go
-./helloworld.go
-./if.go
-./if1.go
-./import.go
-./import1.go
-./import2.go
-./import3.go
-./import4.go
-./indirect.go
-./indirect1.go
-./initcomma.go
-./initialize.go
-./initializerr.go
-./initsyscall.go
-./int_lit.go
-./intcvt.go
-./iota.go
-./literal.go
-./malloc1.go
-# ./mallocfin.go # fail
-./mallocrand.go
-./mallocrep.go
-./mallocrep1.go
-# ./map.go # fail
-./method.go
-./method1.go
-./method2.go
-./method3.go
-./named.go
-./named1.go
-./nil.go
-./nul1.go
-./parentype.go
-./peano.go
-./printbig.go
-./range.go
-./recover.go
-./recover1.go
-./recover2.go
-# ./recover3.go # fail
-./rename.go
-./rename1.go
-./runtime.go
-./sieve.go
-./sigchld.go
-./simassign.go
-./sinit.go
-./stack.go
-./string_lit.go
-./stringrange.go
-./switch.go
-./switch1.go
-./test0.go
-./turing.go
-./typeswitch.go
-./typeswitch1.go
-./typeswitch2.go
-./undef.go
-./utf.go
-./varerr.go
-./varinit.go
-./vectors.go
-./zerodivide.go
-ken/array.go
-ken/chan.go
-ken/chan1.go
-ken/complit.go
-# ken/cplx0.go # output fail
-# ken/cplx1.go # fail
-# ken/cplx2.go # fail
-# ken/cplx3.go # output fail
-# ken/cplx4.go # fail, BUG
-# ken/cplx5.go # output fail
-ken/divconst.go
-ken/divmod.go
-ken/embed.go
-ken/for.go
-ken/interbasic.go
-ken/interfun.go
-ken/intervar.go
-ken/label.go
-ken/litfun.go
-ken/mfunc.go
-ken/modconst.go
-ken/ptrfun.go
-ken/ptrvar.go
-ken/range.go
-ken/rob1.go
-ken/rob2.go
-ken/robfor.go
-ken/robfunc.go
-ken/robif.go
-ken/shift.go
-ken/simparray.go
-ken/simpbool.go
-ken/simpconv.go
-ken/simpfun.go
-ken/simpprint.go
-ken/simpswitch.go
-ken/simpvar.go
-ken/slicearray.go
-ken/sliceslice.go
-ken/string.go
-ken/strvar.go
-chan/doubleselect.go
-chan/fifo.go
-chan/goroutines.go
-chan/nonblock.go
-chan/perm.go
-chan/powser1.go
-chan/powser2.go
-chan/select.go
-chan/select2.go
-# chan/select3.go # fail
-chan/sieve1.go
-chan/sieve2.go
-interface/bigdata.go
-interface/convert.go
-interface/convert1.go
-interface/convert2.go
-interface/embed.go
-interface/embed0.go
-interface/embed1.go
-interface/explicit.go
-interface/fail.go
-interface/fake.go
-interface/pointer.go
-interface/receiver.go
-interface/receiver1.go
-interface/recursive.go
-interface/returntype.go
-interface/struct.go
-nilptr/arrayindex.go
-nilptr/arrayindex1.go
-nilptr/arraytoslice.go
-nilptr/arraytoslice1.go
-nilptr/arraytoslice2.go
-nilptr/slicearray.go
-nilptr/structfield.go
-nilptr/structfield1.go
-nilptr/structfield2.go
-nilptr/structfieldaddr.go
-syntax/forvar.go
-syntax/import.go
-syntax/interface.go
-syntax/semi1.go
-syntax/semi2.go
-syntax/semi3.go
-syntax/semi4.go
-syntax/semi5.go
-syntax/semi6.go
-syntax/semi7.go
-syntax/slice.go
-syntax/topexpr.go
-syntax/vareq.go
-syntax/vareq1.go
-fixedbugs/bug000.go
-fixedbugs/bug001.go
-fixedbugs/bug002.go
-fixedbugs/bug003.go
-fixedbugs/bug004.go
-fixedbugs/bug005.go
-fixedbugs/bug006.go
-fixedbugs/bug007.go
-fixedbugs/bug008.go
-fixedbugs/bug009.go
-fixedbugs/bug010.go
-fixedbugs/bug011.go
-fixedbugs/bug012.go
-fixedbugs/bug013.go
-fixedbugs/bug014.go
-fixedbugs/bug015.go
-fixedbugs/bug016.go
-fixedbugs/bug017.go
-fixedbugs/bug020.go
-fixedbugs/bug021.go
-fixedbugs/bug022.go
-fixedbugs/bug023.go
-fixedbugs/bug024.go
-fixedbugs/bug026.go
-fixedbugs/bug027.go
-fixedbugs/bug028.go
-fixedbugs/bug030.go
-fixedbugs/bug031.go
-fixedbugs/bug035.go
-fixedbugs/bug036.go
-fixedbugs/bug037.go
-fixedbugs/bug038.go
-fixedbugs/bug039.go
-fixedbugs/bug040.go
-fixedbugs/bug045.go
-fixedbugs/bug046.go
-fixedbugs/bug047.go
-fixedbugs/bug048.go
-fixedbugs/bug049.go
-fixedbugs/bug050.go
-fixedbugs/bug051.go
-fixedbugs/bug052.go
-fixedbugs/bug053.go
-fixedbugs/bug054.go
-fixedbugs/bug055.go
-fixedbugs/bug056.go
-fixedbugs/bug057.go
-fixedbugs/bug058.go
-fixedbugs/bug059.go
-fixedbugs/bug060.go
-fixedbugs/bug061.go
-fixedbugs/bug062.go
-fixedbugs/bug063.go
-fixedbugs/bug064.go
-fixedbugs/bug065.go
-fixedbugs/bug066.go
-fixedbugs/bug067.go
-fixedbugs/bug068.go
-fixedbugs/bug069.go
-fixedbugs/bug070.go
-fixedbugs/bug071.go
-fixedbugs/bug072.go
-fixedbugs/bug073.go
-fixedbugs/bug074.go
-fixedbugs/bug075.go
-fixedbugs/bug076.go
-fixedbugs/bug077.go
-fixedbugs/bug078.go
-fixedbugs/bug080.go
-fixedbugs/bug081.go
-fixedbugs/bug082.go
-fixedbugs/bug083.go
-fixedbugs/bug084.go
-fixedbugs/bug085.go
-fixedbugs/bug086.go
-fixedbugs/bug087.go
-fixedbugs/bug088.go
-fixedbugs/bug089.go
-fixedbugs/bug090.go
-fixedbugs/bug091.go
-fixedbugs/bug092.go
-fixedbugs/bug093.go
-fixedbugs/bug094.go
-fixedbugs/bug096.go
-fixedbugs/bug097.go
-fixedbugs/bug098.go
-fixedbugs/bug099.go
-fixedbugs/bug101.go
-fixedbugs/bug102.go
-fixedbugs/bug103.go
-fixedbugs/bug104.go
-fixedbugs/bug106.go
-fixedbugs/bug107.go
-fixedbugs/bug108.go
-fixedbugs/bug109.go
-fixedbugs/bug110.go
-fixedbugs/bug111.go
-fixedbugs/bug112.go
-fixedbugs/bug113.go
-fixedbugs/bug114.go
-fixedbugs/bug115.go
-fixedbugs/bug116.go
-fixedbugs/bug117.go
-fixedbugs/bug118.go
-fixedbugs/bug119.go
-fixedbugs/bug120.go
-fixedbugs/bug121.go
-fixedbugs/bug122.go
-fixedbugs/bug123.go
-fixedbugs/bug126.go
-fixedbugs/bug127.go
-fixedbugs/bug128.go
-fixedbugs/bug129.go
-fixedbugs/bug130.go
-fixedbugs/bug131.go
-fixedbugs/bug132.go
-fixedbugs/bug133.go
-fixedbugs/bug135.go
-fixedbugs/bug136.go
-fixedbugs/bug137.go
-fixedbugs/bug139.go
-fixedbugs/bug140.go
-fixedbugs/bug141.go
-fixedbugs/bug142.go
-fixedbugs/bug143.go
-fixedbugs/bug144.go
-fixedbugs/bug145.go
-fixedbugs/bug146.go
-fixedbugs/bug147.go
-fixedbugs/bug148.go
-fixedbugs/bug149.go
-fixedbugs/bug150.go
-fixedbugs/bug151.go
-fixedbugs/bug152.go
-fixedbugs/bug154.go
-fixedbugs/bug155.go
-fixedbugs/bug156.go
-fixedbugs/bug157.go
-fixedbugs/bug158.go
-fixedbugs/bug159.go
-fixedbugs/bug160.go
-fixedbugs/bug161.go
-fixedbugs/bug163.go
-fixedbugs/bug164.go
-fixedbugs/bug165.go
-fixedbugs/bug167.go
-fixedbugs/bug168.go
-fixedbugs/bug169.go
-fixedbugs/bug170.go
-fixedbugs/bug171.go
-fixedbugs/bug172.go
-fixedbugs/bug173.go
-fixedbugs/bug174.go
-fixedbugs/bug175.go
-fixedbugs/bug176.go
-fixedbugs/bug177.go
-fixedbugs/bug178.go
-fixedbugs/bug179.go
-fixedbugs/bug180.go
-fixedbugs/bug181.go
-fixedbugs/bug182.go
-fixedbugs/bug183.go
-fixedbugs/bug184.go
-fixedbugs/bug185.go
-fixedbugs/bug186.go
-fixedbugs/bug187.go
-fixedbugs/bug188.go
-fixedbugs/bug189.go
-fixedbugs/bug190.go
-fixedbugs/bug191.go
-fixedbugs/bug192.go
-fixedbugs/bug193.go
-fixedbugs/bug194.go
-fixedbugs/bug195.go
-fixedbugs/bug196.go
-fixedbugs/bug197.go
-fixedbugs/bug198.go
-fixedbugs/bug199.go
-fixedbugs/bug200.go
-fixedbugs/bug201.go
-fixedbugs/bug202.go
-fixedbugs/bug203.go
-fixedbugs/bug204.go
-fixedbugs/bug205.go
-fixedbugs/bug206.go
-fixedbugs/bug207.go
-fixedbugs/bug208.go
-fixedbugs/bug209.go
-fixedbugs/bug211.go
-fixedbugs/bug212.go
-fixedbugs/bug213.go
-fixedbugs/bug214.go
-fixedbugs/bug215.go
-fixedbugs/bug216.go
-fixedbugs/bug217.go
-fixedbugs/bug218.go
-fixedbugs/bug219.go
-fixedbugs/bug220.go
-fixedbugs/bug221.go
-fixedbugs/bug222.go
-fixedbugs/bug223.go
-fixedbugs/bug224.go
-fixedbugs/bug225.go
-fixedbugs/bug226.go
-fixedbugs/bug227.go
-fixedbugs/bug228.go
-fixedbugs/bug229.go
-fixedbugs/bug230.go
-fixedbugs/bug231.go
-fixedbugs/bug232.go
-fixedbugs/bug233.go
-fixedbugs/bug234.go
-fixedbugs/bug235.go
-fixedbugs/bug236.go
-fixedbugs/bug237.go
-fixedbugs/bug238.go
-fixedbugs/bug239.go
-fixedbugs/bug240.go
-fixedbugs/bug241.go
-fixedbugs/bug242.go
-# fixedbugs/bug243.go # fail, flaky on android build
-fixedbugs/bug244.go
-fixedbugs/bug245.go
-fixedbugs/bug246.go
-fixedbugs/bug247.go
-fixedbugs/bug248.go
-fixedbugs/bug249.go
-fixedbugs/bug250.go
-fixedbugs/bug251.go
-fixedbugs/bug252.go
-fixedbugs/bug253.go
-fixedbugs/bug254.go
-fixedbugs/bug255.go
-fixedbugs/bug256.go
-fixedbugs/bug257.go
-fixedbugs/bug258.go
-fixedbugs/bug259.go
-fixedbugs/bug261.go
-fixedbugs/bug262.go
-fixedbugs/bug263.go
-fixedbugs/bug264.go
-fixedbugs/bug265.go
-fixedbugs/bug266.go
-fixedbugs/bug267.go
-fixedbugs/bug268.go
-fixedbugs/bug269.go
-fixedbugs/bug270.go
-fixedbugs/bug271.go
-fixedbugs/bug272.go
-fixedbugs/bug273.go
-fixedbugs/bug274.go
-fixedbugs/bug275.go
-fixedbugs/bug276.go
-fixedbugs/bug277.go
-fixedbugs/bug278.go
-fixedbugs/bug279.go
-fixedbugs/bug280.go
-fixedbugs/bug281.go
-fixedbugs/bug282.go
-fixedbugs/bug283.go
-fixedbugs/bug284.go
-fixedbugs/bug285.go
-fixedbugs/bug286.go
-fixedbugs/bug287.go
-fixedbugs/bug288.go
-fixedbugs/bug289.go
-fixedbugs/bug290.go
-fixedbugs/bug291.go
-fixedbugs/bug292.go
-fixedbugs/bug293.go
-fixedbugs/bug294.go
-fixedbugs/bug295.go
-fixedbugs/bug296.go
-fixedbugs/bug297.go
-fixedbugs/bug298.go
-# bugs/bug260.go # fail, BUG
--- /dev/null
+# 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.
+
+include ../../src/Make.inc
+
+all:
+ @echo "make clean or timing"
+
+timing:
+ ./timing.sh
+
+clean:
+ rm -f [568].out *.[568]
+++ /dev/null
-#!/bin/sh
-
-OS=568
-rm -f [$OS].out *.[$OS]
)
var n = flag.Int("n", 7, "count")
-var nCPU = flag.Int("ncpu", 2, "number of cpus")
+var nCPU = flag.Int("ncpu", 4, "number of cpus")
type Job struct {
start []int
#include <stdlib.h>
#include <string.h>
+#ifndef fwrite_unlocked
// not available on OS X
#define fwrite_unlocked fwrite
#define fputc_unlocked fputc
#define fputs_unlocked fputs
+#endif
#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
#define unlikely(x) __builtin_expect((x), 0)
">THREE Homo sapiens frequency\n", n*5, &rand);
return 0;
-}
\ No newline at end of file
+}
package main
import (
- "bytes"
"flag"
"os"
)
const Line = 60
func Repeat(alu []byte, n int) {
- buf := bytes.Add(alu, alu)
+ buf := append(alu, alu...)
off := 0
for n > 0 {
m := n
flag.Parse()
iub := []Acid{
- Acid{prob: 0.27, sym: 'a'},
- Acid{prob: 0.12, sym: 'c'},
- Acid{prob: 0.12, sym: 'g'},
- Acid{prob: 0.27, sym: 't'},
- Acid{prob: 0.02, sym: 'B'},
- Acid{prob: 0.02, sym: 'D'},
- Acid{prob: 0.02, sym: 'H'},
- Acid{prob: 0.02, sym: 'K'},
- Acid{prob: 0.02, sym: 'M'},
- Acid{prob: 0.02, sym: 'N'},
- Acid{prob: 0.02, sym: 'R'},
- Acid{prob: 0.02, sym: 'S'},
- Acid{prob: 0.02, sym: 'V'},
- Acid{prob: 0.02, sym: 'W'},
- Acid{prob: 0.02, sym: 'Y'},
+ {prob: 0.27, sym: 'a'},
+ {prob: 0.12, sym: 'c'},
+ {prob: 0.12, sym: 'g'},
+ {prob: 0.27, sym: 't'},
+ {prob: 0.02, sym: 'B'},
+ {prob: 0.02, sym: 'D'},
+ {prob: 0.02, sym: 'H'},
+ {prob: 0.02, sym: 'K'},
+ {prob: 0.02, sym: 'M'},
+ {prob: 0.02, sym: 'N'},
+ {prob: 0.02, sym: 'R'},
+ {prob: 0.02, sym: 'S'},
+ {prob: 0.02, sym: 'V'},
+ {prob: 0.02, sym: 'W'},
+ {prob: 0.02, sym: 'Y'},
}
homosapiens := []Acid{
- Acid{prob: 0.3029549426680, sym: 'a'},
- Acid{prob: 0.1979883004921, sym: 'c'},
- Acid{prob: 0.1975473066391, sym: 'g'},
- Acid{prob: 0.3015094502008, sym: 't'},
+ {prob: 0.3029549426680, sym: 'a'},
+ {prob: 0.1979883004921, sym: 'c'},
+ {prob: 0.1975473066391, sym: 'g'},
+ {prob: 0.3015094502008, sym: 't'},
}
alu := []byte(
func (b *buffer) WriteString(s string) {
p := b.NextWrite(len(s))
- for i := 0; i < len(s); i++ {
- p[i] = s[i]
- }
+ copy(p, s)
}
func (b *buffer) NextWrite(n int) []byte {
p = *b
}
out := p[len(p) : len(p)+n]
- *b = p[0 : len(p)+n]
+ *b = p[:len(p)+n]
return out
}
"fmt"
"io/ioutil"
"os"
+ "runtime"
"sort"
)
}
func main() {
+ runtime.GOMAXPROCS(4)
in := bufio.NewReader(os.Stdin)
three := []byte(">THREE ")
for {
var (
tmp1 = big.NewInt(0)
tmp2 = big.NewInt(0)
+ tmp3 = big.NewInt(0)
y2 = big.NewInt(0)
bigk = big.NewInt(0)
numer = big.NewInt(1)
}
func next_term(k int64) {
- // TODO(eds) If big.Int ever gets a Scale method, y2 and bigk could be int64
y2.SetInt64(k*2 + 1)
bigk.SetInt64(k)
}
func eliminate_digit(d int64) {
- tmp := big.NewInt(0).Set(denom)
- accum.Sub(accum, tmp.Mul(tmp, big.NewInt(d)))
+ tmp3.SetInt64(d)
+ accum.Sub(accum, tmp3.Mul(denom, tmp3))
accum.Mul(accum, ten)
numer.Mul(numer, ten)
}
func printf(s string, arg ...interface{}) {
if !*silent {
- fmt.Printf(s, arg)
+ fmt.Printf(s, arg...)
}
}
gc mandelbrot 74.32u 0.00s 74.35r
gc_B mandelbrot 74.28u 0.01s 74.31r
-meteor 16000
+meteor 2100
# we don't know
gcc -O2 meteor-contest.c 0.10u 0.00s 0.10r
gccgo -O2 meteor-contest.go 0.12u 0.00s 0.14r
gc mandelbrot 64.05u 0.02s 64.08r # *** -14%
gc_B mandelbrot 64.10u 0.02s 64.14r # *** -14%
-meteor 16000
+meteor 2100
# we don't know
gcc -O2 meteor-contest.c 0.10u 0.00s 0.10r
gccgo -O2 meteor-contest.go 0.12u 0.00s 0.12r
gc mandelbrot 63.31u 0.01s 63.35r # -1%
gc_B mandelbrot 63.29u 0.00s 63.31r # -1%
-meteor 16000
+meteor 2100
# we don't know
gcc -O2 meteor-contest.c 0.10u 0.00s 0.10r
gccgo -O2 meteor-contest.go 0.11u 0.00s 0.12r
gcc -O2 chameneosredux.c -lpthread 18.00u 303.29s 83.64r
gc chameneosredux 12.10u 0.00s 12.10r # 2.22X faster
-Jan 6, 2009
+Jan 6, 2010
# Long-overdue update. All numbers included in this complete run.
# Some programs (e.g. reverse-complement) rewritten for speed.
reverse-complement < output-of-fasta-25000000
gcc -O2 reverse-complement.c 2.00u 0.80s 9.54r
- gccgo -O2 reverse-complement.go 4.57u 0.35s 4.94r # 33% faster
+# gccgo -O2 reverse-complement.go 4.57u 0.35s 4.94r # 33% faster
gc reverse-complement 2.01u 0.38s 2.40r # 3.3X faster
gc_B reverse-complement 1.88u 0.36s 2.24r # 3.2X faster
GOGC=off
binary-tree 15 # too slow to use 20
gcc -O2 binary-tree.c -lm 0.86u 0.00s 0.87r
gccgo -O2 binary-tree.go 4.82u 0.41s 5.24r # 2.5X slower
- gccgo -O2 binary-tree-freelist.go 0.00u 0.00s 0.00r
gc binary-tree 7.23u 0.01s 7.25r # # -19%
gc binary-tree-freelist 0.43u 0.00s 0.44r # -9%
gc mandelbrot 66.05u 0.00s 66.07r # -3%
gc_B mandelbrot 66.06u 0.00s 66.07r # -3%
-meteor 16000
+meteor 2100
gcc -O2 meteor-contest.c 0.10u 0.00s 0.10r
gccgo -O2 meteor-contest.go 0.12u 0.00s 0.12r
gc meteor-contest 0.17u 0.00s 0.17r
gcc -O2 chameneosredux.c -lpthread 19.02u 331.08s 90.79r
gc chameneosredux 12.54u 0.00s 12.55r
+Oct 19, 2010
+
+# Another long-overdue update. Some of the code is new; parallel versions
+# of some are added. A few significant improvements.
+
+fasta -n 25000000
+ gcc -O2 fasta.c 4.92u 0.00s 4.93r
+ gccgo -O2 fasta.go 3.31u 0.00s 3.34r # new code
+ gc fasta 3.68u 0.00s 3.69r # 2.5X faster with no code
+ gc_B fasta 3.68u 0.00s 3.69r # 2.3X faster with no code
+
+reverse-complement < output-of-fasta-25000000
+ gcc -O2 reverse-complement.c 1.93u 0.81s 11.24r
+ gccgo -O2 reverse-complement.go 1.58u 0.43s 2.04r # first run with new code?
+ gc reverse-complement 1.84u 0.34s 2.20r # 10% faster
+ gc_B reverse-complement 1.85u 0.32s 2.18r
+
+nbody -n 50000000
+ gcc -O2 nbody.c 21.35u 0.00s 21.36r
+ gccgo -O2 nbody.go 21.62u 0.00s 21.66r # 3.7X faster - why??
+ gc nbody 29.78u 0.00s 29.79r
+ gc_B nbody 29.72u 0.00s 29.72r
+
+binary-tree 15 # too slow to use 20
+ gcc -O2 binary-tree.c -lm 0.86u 0.00s 0.88r
+ gccgo -O2 binary-tree.go 4.05u 0.02s 4.08r # 28% faster
+ gccgo -O2 binary-tree-freelist 0.34u 0.08s 0.34r
+ gc binary-tree 5.94u 0.00s 5.95r # 20% faster
+ gc binary-tree-freelist 0.50u 0.01s 0.54r
+
+fannkuch 12
+ gcc -O2 fannkuch.c 60.45u 0.00s 60.45r
+ gccgo -O2 fannkuch.go 64.64u 0.00s 64.64r
+ gccgo -O2 fannkuch-parallel.go 115.63u 0.00s 31.58r
+ gc fannkuch 126.52u 0.04s 126.68r
+ gc fannkuch-parallel 238.82u 0.10s 65.93r # GOMAXPROCS=4
+ gc_B fannkuch 88.99u 0.00s 89.02r
+
+regex-dna 100000
+ gcc -O2 regex-dna.c -lpcre 0.89u 0.00s 0.89r
+ gc regex-dna 8.99u 0.02s 9.03r
+ gc regex-dna-parallel 8.94u 0.02s 3.68r # GOMAXPROCS=4
+ gc_B regex-dna 9.12u 0.00s 9.14r
+
+spectral-norm 5500
+ gcc -O2 spectral-norm.c -lm 11.55u 0.00s 11.57r
+ gccgo -O2 spectral-norm.go 11.73u 0.00s 11.75r
+ gc spectral-norm 23.74u 0.00s 23.79r
+ gc_B spectral-norm 24.49u 0.02s 24.54r
+
+k-nucleotide 1000000
+ gcc -O2 k-nucleotide.c 11.44u 0.06s 11.50r
+ gccgo -O2 k-nucleotide.go 8.65u 0.04s 8.71r
+ gccgo -O2 k-nucleotide-parallel.go 8.75u 0.03s 2.97r # set GOMAXPROCS=4
+ gc k-nucleotide 14.92u 0.05s 15.01r
+ gc k-nucleotide-parallel 16.96u 0.06s 6.53r # set GOMAXPROCS=4
+ gc_B k-nucleotide 15.97u 0.03s 16.08r
+
+mandelbrot 16000
+ gcc -O2 mandelbrot.c 56.32u 0.00s 56.35r
+ gccgo -O2 mandelbrot.go 55.62u 0.02s 55.77r
+ gc mandelbrot 64.85u 0.01s 64.94r
+ gc_B mandelbrot 65.02u 0.01s 65.14r
+
+meteor 2100
+ gcc -O2 meteor-contest.c 0.10u 0.00s 0.10r
+ gccgo -O2 meteor-contest.go 0.10u 0.00s 0.11r
+ gc meteor-contest 0.17u 0.00s 0.18r
+ gc_B meteor-contest 0.16u 0.00s 0.16r
+
+pidigits 10000
+ gcc -O2 pidigits.c -lgmp 2.58u 0.00s 2.59r
+ gccgo -O2 pidigits.go 14.06u 0.01s 14.09r # first run?
+ gc pidigits 8.47u 0.05s 8.55r # 4.5X faster due to package big
+ gc_B pidigits 8.33u 0.01s 8.36r # 4.5X faster due to package big
+
+threadring 50000000
+ gcc -O2 threadring.c 28.18u 153.19s 186.47r
+ gccgo -O2 threadring.go 110.10u 516.48s 515.25r
+ gc threadring 40.39u 0.00s 40.40r
+
+chameneos 6000000
+ gcc -O2 chameneosredux.c -lpthread 18.20u 301.55s 83.10r
+ gccgo -O2 chameneosredux.go 52.22u 324.54s 201.21r
+ gc chameneosredux 13.52u 0.00s 13.54r
+
+Dec 14, 2010
+
+# Improved regex code (same algorithm) gets ~30%.
+
+regex-dna 100000
+ gcc -O2 regex-dna.c -lpcre 0.77u 0.01s 0.78r
+ gc regex-dna 6.80u 0.00s 6.81r
+ gc regex-dna-parallel 6.82u 0.01s 2.75r
+ gc_B regex-dna 6.69u 0.02s 6.70r
+
+Feb 15, 2011
+
+# Improved GC, still single-threaded but more efficient
+
+fasta -n 25000000
+ gcc -O2 fasta.c 3.40u 0.00s 3.40r
+ gccgo -O2 fasta.go 3.51u 0.00s 3.50r
+ gc fasta 3.66u 0.01s 3.66r
+ gc_B fasta 3.66u 0.00s 3.66r
+
+reverse-complement < output-of-fasta-25000000
+ gcc -O2 reverse-complement.c 1.86u 1.29s 4.93r
+ gccgo -O2 reverse-complement.go 2.18u 0.41s 2.60r
+ gc reverse-complement 1.67u 0.48s 2.15r
+ gc_B reverse-complement 1.71u 0.45s 2.15r
+
+nbody -n 50000000
+ gcc -O2 -lm nbody.c 21.64u 0.00s 21.64r
+ gccgo -O2 nbody.go 21.46u 0.00s 21.45r
+ gc nbody 29.07u 0.00s 29.06r
+ gc_B nbody 31.61u 0.00s 31.61r
+
+binary-tree 15 # too slow to use 20
+ gcc -O2 binary-tree.c -lm 0.88u 0.00s 0.87r
+ gccgo -O2 binary-tree.go 2.74u 0.07s 2.81r
+ gccgo -O2 binary-tree-freelist.go 0.01u 0.00s 0.00r
+ gc binary-tree 4.22u 0.02s 4.24r
+ gc binary-tree-freelist 0.54u 0.02s 0.55r
+
+fannkuch 12
+ gcc -O2 fannkuch.c 57.64u 0.00s 57.64r
+ gccgo -O2 fannkuch.go 65.79u 0.00s 65.82r
+ gccgo -O2 fannkuch-parallel.go 160.91u 0.02s 43.90r
+ gc fannkuch 126.36u 0.03s 126.53r
+ gc fannkuch-parallel 175.23u 0.04s 45.49r
+ gc_B fannkuch 89.23u 0.00s 89.24r
+
+regex-dna 100000
+ gcc -O2 regex-dna.c -lpcre 0.77u 0.01s 0.80r
+ gccgo -O2 regex-dna.go 12.38u 0.10s 12.52r
+ gccgo -O2 regex-dna-parallel.go 43.96u 4.64s 15.11r
+ gc regex-dna 7.03u 0.01s 7.05r
+ gc regex-dna-parallel 6.85u 0.05s 2.70r
+ gc_B regex-dna 6.87u 0.02s 6.89r
+
+spectral-norm 5500
+ gcc -O2 spectral-norm.c -lm 12.29u 0.00s 12.28r
+ gccgo -O2 spectral-norm.go 11.79u 0.00s 11.79r
+ gc spectral-norm 24.00u 0.02s 24.05r
+ gc_B spectral-norm 24.59u 0.01s 24.59r
+
+k-nucleotide 1000000
+ gcc -O2 k-nucleotide.c 9.75u 0.07s 9.82r
+ gccgo -O2 k-nucleotide.go 8.92u 0.06s 8.98r
+ gccgo -O2 k-nucleotide-parallel.go 8.40u 0.04s 2.76r
+ gc k-nucleotide 17.01u 0.03s 17.04r
+ gc k-nucleotide-parallel 16.51u 0.08s 6.21r
+ gc_B k-nucleotide 16.94u 0.08s 17.02r
+
+mandelbrot 16000
+ gcc -O2 mandelbrot.c 54.60u 0.00s 54.66r
+ gccgo -O2 mandelbrot.go 59.38u 0.00s 59.41r
+ gc mandelbrot 64.93u 0.04s 65.08r
+ gc_B mandelbrot 64.85u 0.03s 64.92r
+
+meteor 2098
+ gcc -O2 meteor-contest.c 0.10u 0.01s 0.10r
+ gccgo -O2 meteor-contest.go 0.11u 0.00s 0.11r
+ gc meteor-contest 0.18u 0.00s 0.17r
+ gc_B meteor-contest 0.17u 0.00s 0.16r
+
+pidigits 10000
+ gcc -O2 pidigits.c -lgmp 2.24u 0.00s 2.23r
+ gccgo -O2 pidigits.go 14.05u 0.00s 14.06r
+ gc pidigits 6.34u 0.05s 6.38r
+ gc_B pidigits 6.37u 0.02s 6.38r
+
+threadring 50000000
+ gcc -O2 threadring.c 30.50u 258.05s 325.72r
+ gccgo -O2 threadring.go 92.87u 748.39s 728.46r
+ gc threadring 38.03u 0.01s 38.04r
eval $(gomake --no-print-directory -f ../../src/Make.inc go-env)
PATH=.:$PATH
+havegccgo=false
+if which gccgo >/dev/null 2>&1
+then
+ havegccgo=true
+fi
+
mode=run
case X"$1" in
X-test)
fi
}
-
-
run() {
if [ $mode = test ]
then
fi
return
fi
+ if ! $havegccgo && echo $1 | grep -q '^gccgo '
+ then
+ return
+ fi
echo -n ' '$1' '
$1
shift
fasta() {
runonly echo 'fasta -n 25000000'
run 'gcc -O2 fasta.c' a.out 25000000
- #run 'gccgo -O2 fasta.go' a.out -n 25000000 #commented out until WriteString is in bufio
+ run 'gccgo -O2 fasta.go' a.out -n 25000000 #commented out until WriteString is in bufio
run 'gc fasta' $O.out -n 25000000
run 'gc_B fasta' $O.out -n 25000000
}
nbody() {
runonly echo 'nbody -n 50000000'
- run 'gcc -O2 nbody.c' a.out 50000000
+ run 'gcc -O2 -lm nbody.c' a.out 50000000
run 'gccgo -O2 nbody.go' a.out -n 50000000
run 'gc nbody' $O.out -n 50000000
run 'gc_B nbody' $O.out -n 50000000
runonly a.out 100000 > x
runonly echo 'regex-dna 100000'
run 'gcc -O2 regex-dna.c -lpcre' a.out <x
-# run 'gccgo -O2 regex-dna.go' a.out <x # pages badly; don't run
+ run 'gccgo -O2 regex-dna.go' a.out <x
+ run 'gccgo -O2 regex-dna-parallel.go' a.out <x
run 'gc regex-dna' $O.out <x
run 'gc regex-dna-parallel' $O.out <x
run 'gc_B regex-dna' $O.out <x
runonly a.out 1000000 > x # should be using 25000000
runonly echo 'k-nucleotide 1000000'
run 'gcc -O2 -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include k-nucleotide.c -lglib-2.0' a.out <x
- run 'gccgo -O2 k-nucleotide.go' a.out <x # warning: pages badly!
- run 'gccgo -O2 k-nucleotide-parallel.go' a.out <x # warning: pages badly!
+ run 'gccgo -O2 k-nucleotide.go' a.out <x
+ run 'gccgo -O2 k-nucleotide-parallel.go' a.out <x
run 'gc k-nucleotide' $O.out <x
run 'gc k-nucleotide-parallel' $O.out <x
run 'gc_B k-nucleotide' $O.out <x
}
meteor() {
- runonly echo 'meteor 16000'
- run 'gcc -O2 meteor-contest.c' a.out
- run 'gccgo -O2 meteor-contest.go' a.out
- run 'gc meteor-contest' $O.out
- run 'gc_B meteor-contest' $O.out
+ runonly echo 'meteor 2098'
+ run 'gcc -O2 meteor-contest.c' a.out 2098
+ run 'gccgo -O2 meteor-contest.go' a.out -n 2098
+ run 'gc meteor-contest' $O.out -n 2098
+ run 'gc_B meteor-contest' $O.out -n 2098
}
pidigits() {
runonly echo 'pidigits 10000'
run 'gcc -O2 pidigits.c -lgmp' a.out 10000
-# run 'gccgo -O2 pidigits.go' a.out -n 10000 # uncomment when gccgo library updated
+ run 'gccgo -O2 pidigits.go' a.out -n 10000
run 'gc pidigits' $O.out -n 10000
run 'gc_B pidigits' $O.out -n 10000
}
+++ /dev/null
-// $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(os.Args) > 1
- status := 0
- var b1 [10]T1
- a0, _ := strconv.Btoui64(fmt.Sprintf("%p", &b1[0])[2:], 16)
- a1, _ := strconv.Btoui64(fmt.Sprintf("%p", &b1[1])[2:], 16)
- if a1 != a0 + 1 {
- fmt.Println("FAIL")
- if report {
- fmt.Println("alignment should be 1, is", a1-a0)
- }
- status = 1
- }
- var b2 [10]T2
- a0, _ = strconv.Btoui64(fmt.Sprintf("%p", &b2[0])[2:], 16)
- a1, _ = strconv.Btoui64(fmt.Sprintf("%p", &b2[1])[2:], 16)
- if a1 != a0 + 2 {
- if status == 0 {
- fmt.Println("FAIL")
- status = 1
- }
- if report {
- fmt.Println("alignment should be 2, is", a1-a0)
- }
- }
- var b4 [10]T4
- a0, _ = strconv.Btoui64(fmt.Sprintf("%p", &b4[0])[2:], 16)
- a1, _ = strconv.Btoui64(fmt.Sprintf("%p", &b4[1])[2:], 16)
- if a1 != a0 + 4 {
- if status == 0 {
- fmt.Println("FAIL")
- status = 1
- }
- if report {
- fmt.Println("alignment should be 4, is", a1-a0)
- }
- }
- os.Exit(status)
-}
--- /dev/null
+// 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() {
+}
--- /dev/null
+// 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.
+ // var i1 I = t
+ // i1.M()
+
+ // This combination is illegal because
+ // PM requires a pointer receiver.
+ // var pi1 PI = t
+ // pi1.PM()
+
+ var pt = &t
+ pt.M()
+ pt.PM()
+
+ var i2 I = pt
+ i2.M()
+
+ var pi2 PI = pt
+ pi2.PM()
+}
+
+/*
+These should not be errors anymore:
+
+bug322.dir/main.go:19: implicit assignment of unexported field 'x' of lib.T in method receiver
+bug322.dir/main.go:32: implicit assignment of unexported field 'x' of lib.T in method receiver
+*/
--- /dev/null
+// $G $D/$F.dir/lib.go && $G $D/$F.dir/main.go && $L main.$A && ./$A.out || echo BUG: fails incorrectly
+
+// 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 case for issue 1402.
+ignored
--- /dev/null
+// 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 (
+ "./p"
+)
+
+type Exported interface {
+ private()
+}
+
+type Implementation struct{}
+
+func (p *Implementation) private() { println("main.Implementation.private()") }
+
+
+func main() {
+ // nothing unusual here
+ var x Exported
+ x = new(Implementation)
+ x.private() // main.Implementation.private()
+
+ // same here - should be and is legal
+ var px p.Exported
+ px = p.X
+
+ // this assignment is correctly illegal:
+ // px.private undefined (cannot refer to unexported field or method private)
+ // px.private()
+
+ // this assignment is correctly illegal:
+ // *Implementation does not implement p.Exported (missing p.private method)
+ // px = new(Implementation)
+
+ // this assignment is correctly illegal:
+ // p.Exported does not implement Exported (missing private method)
+ // x = px
+
+ // this assignment unexpectedly compiles and then executes
+ x = px.(Exported)
+
+ // this is a legitimate call, but because of the previous assignment,
+ // it invokes the method private in p!
+ x.private() // p.Implementation.private()
+}
--- /dev/null
+// 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() { println("p.Implementation.private()") }
+
+var X = new(Implementation)
--- /dev/null
+// $G $D/$F.dir/p.go && $G $D/$F.dir/main.go && $L main.$A && ! ./$A.out || echo BUG: should fail
+
+// 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 case for issue 1550
+ignored
--- /dev/null
+// $G $D/$F.go && $L $F.$A && ./$A.out
+
+package main
+
+func f() *int {
+ println("BUG: called f")
+ return new(int)
+}
+
+func main() {
+ var x struct {
+ a int
+ }
+ c := make(chan int, 1)
+ c1 := make(chan int)
+ c <- 42
+ select {
+ case *f() = <-c1:
+ // nothing
+ case x.a = <-c:
+ if x.a != 42 {
+ println("BUG:", x.a)
+ }
+ }
+}
--- /dev/null
+// $G $D/$F.go && $L $F.$A && ./$A.out >tmp.go &&
+// $G tmp.go && $L tmp.$A && ./$A.out || echo BUG: select5
+// 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.
+
+// Generate test of channel operations and simple selects.
+// Only doing one real send or receive at a time, but phrased
+// in various ways that the compiler may or may not rewrite
+// into simpler expressions.
+
+package main
+
+import (
+ "bufio"
+ "fmt"
+ "io"
+ "os"
+ "template"
+)
+
+func main() {
+ out := bufio.NewWriter(os.Stdout)
+ fmt.Fprintln(out, header)
+ a := new(arg)
+
+ // Generate each kind of test as a separate function to avoid
+ // hitting the 6g optimizer with one enormous function.
+ // If we name all the functions init we don't have to
+ // maintain a list of which ones to run.
+ do := func(t *template.Template) {
+ fmt.Fprintln(out, `func init() {`)
+ for ; next(); a.reset() {
+ run(t, a, out)
+ }
+ fmt.Fprintln(out, `}`)
+ }
+
+ do(recv)
+ do(send)
+ do(recvOrder)
+ do(sendOrder)
+ do(nonblock)
+
+ fmt.Fprintln(out, "//", a.nreset, "cases")
+ out.Flush()
+}
+
+func run(t *template.Template, a interface{}, out io.Writer) {
+ if err := t.Execute(out, a); err != nil {
+ panic(err)
+ }
+}
+
+type arg struct{
+ def bool
+ nreset int
+}
+
+func (a *arg) Maybe() bool {
+ return maybe()
+}
+
+func (a *arg) MaybeDefault() bool {
+ if a.def {
+ return false
+ }
+ a.def = maybe()
+ return a.def
+}
+
+func (a *arg) MustDefault() bool {
+ return !a.def
+}
+
+func (a *arg) reset() {
+ a.def = false
+ a.nreset++
+}
+
+const header = `// GENERATED BY select5.go; DO NOT EDIT
+
+package main
+
+// channel is buffered so test is single-goroutine.
+// we are not interested in the concurrency aspects
+// of select, just testing that the right calls happen.
+var c = make(chan int, 1)
+var nilch chan int
+var n = 1
+var x int
+var i interface{}
+var dummy = make(chan int)
+var m = make(map[int]int)
+var order = 0
+
+func f(p *int) *int {
+ return p
+}
+
+// check order of operations by ensuring that
+// successive calls to checkorder have increasing o values.
+func checkorder(o int) {
+ if o <= order {
+ println("invalid order", o, "after", order)
+ panic("order")
+ }
+ order = o
+}
+
+func fc(c chan int, o int) chan int {
+ checkorder(o)
+ return c
+}
+
+func fp(p *int, o int) *int {
+ checkorder(o)
+ return p
+}
+
+func fn(n, o int) int {
+ checkorder(o)
+ return n
+}
+
+func die(x int) {
+ println("have", x, "want", n)
+ panic("chan")
+}
+
+func main() {
+ // everything happens in init funcs
+}
+`
+
+func parse(s string) *template.Template {
+ t := template.New(nil)
+ t.SetDelims("〈", "〉")
+ if err := t.Parse(s); err != nil {
+ panic(s)
+ }
+ return t
+}
+
+var recv = parse(`
+ 〈# Send n, receive it one way or another into x, check that they match.〉
+ c <- n
+ 〈.section Maybe〉
+ x = <-c
+ 〈.or〉
+ select {
+ 〈# Blocking or non-blocking, before the receive.〉
+ 〈# The compiler implements two-case select where one is default with custom code,〉
+ 〈# so test the default branch both before and after the send.〉
+ 〈.section MaybeDefault〉
+ default:
+ panic("nonblock")
+ 〈.end〉
+ 〈# Receive from c. Different cases are direct, indirect, :=, interface, and map assignment.〉
+ 〈.section Maybe〉
+ case x = <-c:
+ 〈.or〉〈.section Maybe〉
+ case *f(&x) = <-c:
+ 〈.or〉〈.section Maybe〉
+ case y := <-c:
+ x = y
+ 〈.or〉〈.section Maybe〉
+ case i = <-c:
+ x = i.(int)
+ 〈.or〉
+ case m[13] = <-c:
+ x = m[13]
+ 〈.end〉〈.end〉〈.end〉〈.end〉
+ 〈# Blocking or non-blocking again, after the receive.〉
+ 〈.section MaybeDefault〉
+ default:
+ panic("nonblock")
+ 〈.end〉
+ 〈# Dummy send, receive to keep compiler from optimizing select.〉
+ 〈.section Maybe〉
+ case dummy <- 1:
+ panic("dummy send")
+ 〈.end〉
+ 〈.section Maybe〉
+ case <-dummy:
+ panic("dummy receive")
+ 〈.end〉
+ 〈# Nil channel send, receive to keep compiler from optimizing select.〉
+ 〈.section Maybe〉
+ case nilch <- 1:
+ panic("nilch send")
+ 〈.end〉
+ 〈.section Maybe〉
+ case <-nilch:
+ panic("nilch recv")
+ 〈.end〉
+ }
+ 〈.end〉
+ if x != n {
+ die(x)
+ }
+ n++
+`)
+
+var recvOrder = parse(`
+ 〈# Send n, receive it one way or another into x, check that they match.〉
+ 〈# Check order of operations along the way by calling functions that check〉
+ 〈# that the argument sequence is strictly increasing.〉
+ order = 0
+ c <- n
+ 〈.section Maybe〉
+ 〈# Outside of select, left-to-right rule applies.〉
+ 〈# (Inside select, assignment waits until case is chosen,〉
+ 〈# so right hand side happens before anything on left hand side.〉
+ *fp(&x, 1) = <-fc(c, 2)
+ 〈.or〉〈.section Maybe〉
+ m[fn(13, 1)] = <-fc(c, 2)
+ x = m[13]
+ 〈.or〉
+ select {
+ 〈# Blocking or non-blocking, before the receive.〉
+ 〈# The compiler implements two-case select where one is default with custom code,〉
+ 〈# so test the default branch both before and after the send.〉
+ 〈.section MaybeDefault〉
+ default:
+ panic("nonblock")
+ 〈.end〉
+ 〈# Receive from c. Different cases are direct, indirect, :=, interface, and map assignment.〉
+ 〈.section Maybe〉
+ case *fp(&x, 100) = <-fc(c, 1):
+ 〈.or〉〈.section Maybe〉
+ case y := <-fc(c, 1):
+ x = y
+ 〈.or〉〈.section Maybe〉
+ case i = <-fc(c, 1):
+ x = i.(int)
+ 〈.or〉
+ case m[fn(13, 100)] = <-fc(c, 1):
+ x = m[13]
+ 〈.end〉〈.end〉〈.end〉
+ 〈# Blocking or non-blocking again, after the receive.〉
+ 〈.section MaybeDefault〉
+ default:
+ panic("nonblock")
+ 〈.end〉
+ 〈# Dummy send, receive to keep compiler from optimizing select.〉
+ 〈.section Maybe〉
+ case fc(dummy, 2) <- fn(1, 3):
+ panic("dummy send")
+ 〈.end〉
+ 〈.section Maybe〉
+ case <-fc(dummy, 4):
+ panic("dummy receive")
+ 〈.end〉
+ 〈# Nil channel send, receive to keep compiler from optimizing select.〉
+ 〈.section Maybe〉
+ case fc(nilch, 5) <- fn(1, 6):
+ panic("nilch send")
+ 〈.end〉
+ 〈.section Maybe〉
+ case <-fc(nilch, 7):
+ panic("nilch recv")
+ 〈.end〉
+ }
+ 〈.end〉〈.end〉
+ if x != n {
+ die(x)
+ }
+ n++
+`)
+
+var send = parse(`
+ 〈# Send n one way or another, receive it into x, check that they match.〉
+ 〈.section Maybe〉
+ c <- n
+ 〈.or〉
+ select {
+ 〈# Blocking or non-blocking, before the receive (same reason as in recv).〉
+ 〈.section MaybeDefault〉
+ default:
+ panic("nonblock")
+ 〈.end〉
+ 〈# Send c <- n. No real special cases here, because no values come back〉
+ 〈# from the send operation.〉
+ case c <- n:
+ 〈# Blocking or non-blocking.〉
+ 〈.section MaybeDefault〉
+ default:
+ panic("nonblock")
+ 〈.end〉
+ 〈# Dummy send, receive to keep compiler from optimizing select.〉
+ 〈.section Maybe〉
+ case dummy <- 1:
+ panic("dummy send")
+ 〈.end〉
+ 〈.section Maybe〉
+ case <-dummy:
+ panic("dummy receive")
+ 〈.end〉
+ 〈# Nil channel send, receive to keep compiler from optimizing select.〉
+ 〈.section Maybe〉
+ case nilch <- 1:
+ panic("nilch send")
+ 〈.end〉
+ 〈.section Maybe〉
+ case <-nilch:
+ panic("nilch recv")
+ 〈.end〉
+ }
+ 〈.end〉
+ x = <-c
+ if x != n {
+ die(x)
+ }
+ n++
+`)
+
+var sendOrder = parse(`
+ 〈# Send n one way or another, receive it into x, check that they match.〉
+ 〈# Check order of operations along the way by calling functions that check〉
+ 〈# that the argument sequence is strictly increasing.〉
+ order = 0
+ 〈.section Maybe〉
+ fc(c, 1) <- fn(n, 2)
+ 〈.or〉
+ select {
+ 〈# Blocking or non-blocking, before the receive (same reason as in recv).〉
+ 〈.section MaybeDefault〉
+ default:
+ panic("nonblock")
+ 〈.end〉
+ 〈# Send c <- n. No real special cases here, because no values come back〉
+ 〈# from the send operation.〉
+ case fc(c, 1) <- fn(n, 2):
+ 〈# Blocking or non-blocking.〉
+ 〈.section MaybeDefault〉
+ default:
+ panic("nonblock")
+ 〈.end〉
+ 〈# Dummy send, receive to keep compiler from optimizing select.〉
+ 〈.section Maybe〉
+ case fc(dummy, 3) <- fn(1, 4):
+ panic("dummy send")
+ 〈.end〉
+ 〈.section Maybe〉
+ case <-fc(dummy, 5):
+ panic("dummy receive")
+ 〈.end〉
+ 〈# Nil channel send, receive to keep compiler from optimizing select.〉
+ 〈.section Maybe〉
+ case fc(nilch, 6) <- fn(1, 7):
+ panic("nilch send")
+ 〈.end〉
+ 〈.section Maybe〉
+ case <-fc(nilch, 8):
+ panic("nilch recv")
+ 〈.end〉
+ }
+ 〈.end〉
+ x = <-c
+ if x != n {
+ die(x)
+ }
+ n++
+`)
+
+var nonblock = parse(`
+ x = n
+ 〈# Test various combinations of non-blocking operations.〉
+ 〈# Receive assignments must not edit or even attempt to compute the address of the lhs.〉
+ select {
+ 〈.section MaybeDefault〉
+ default:
+ 〈.end〉
+ 〈.section Maybe〉
+ case dummy <- 1:
+ panic("dummy <- 1")
+ 〈.end〉
+ 〈.section Maybe〉
+ case nilch <- 1:
+ panic("nilch <- 1")
+ 〈.end〉
+ 〈.section Maybe〉
+ case <-dummy:
+ panic("<-dummy")
+ 〈.end〉
+ 〈.section Maybe〉
+ case x = <-dummy:
+ panic("<-dummy x")
+ 〈.end〉
+ 〈.section Maybe〉
+ case **(**int)(nil) = <-dummy:
+ panic("<-dummy (and didn't crash saving result!)")
+ 〈.end〉
+ 〈.section Maybe〉
+ case <-nilch:
+ panic("<-nilch")
+ 〈.end〉
+ 〈.section Maybe〉
+ case x = <-nilch:
+ panic("<-nilch x")
+ 〈.end〉
+ 〈.section Maybe〉
+ case **(**int)(nil) = <-nilch:
+ panic("<-nilch (and didn't crash saving result!)")
+ 〈.end〉
+ 〈.section MustDefault〉
+ default:
+ 〈.end〉
+ }
+ if x != n {
+ die(x)
+ }
+ n++
+`)
+
+// Code for enumerating all possible paths through
+// some logic. The logic should call choose(n) when
+// it wants to choose between n possibilities.
+// On successive runs through the logic, choose(n)
+// will return 0, 1, ..., n-1. The helper maybe() is
+// similar but returns true and then false.
+//
+// Given a function gen that generates an output
+// using choose and maybe, code can generate all
+// possible outputs using
+//
+// for next() {
+// gen()
+// }
+
+type choice struct {
+ i, n int
+}
+
+var choices []choice
+var cp int = -1
+
+func maybe() bool {
+ return choose(2) == 0
+}
+
+func choose(n int) int {
+ if cp >= len(choices) {
+ // never asked this before: start with 0.
+ choices = append(choices, choice{0, n})
+ cp = len(choices)
+ return 0
+ }
+ // otherwise give recorded answer
+ if n != choices[cp].n {
+ panic("inconsistent choices")
+ }
+ i := choices[cp].i
+ cp++
+ return i
+}
+
+func next() bool {
+ if cp < 0 {
+ // start a new round
+ cp = 0
+ return true
+ }
+
+ // increment last choice sequence
+ cp = len(choices)-1
+ for cp >= 0 && choices[cp].i == choices[cp].n-1 {
+ cp--
+ }
+ if cp < 0 {
+ choices = choices[:0]
+ return false
+ }
+ choices[cp].i++
+ choices = choices[:cp+1]
+ cp = 0
+ return true
+}
+
--- /dev/null
+// $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.
+
+// Test various parsing cases that are a little
+// different now that send is a statement, not a expression.
+
+package main
+
+func main() {
+ chanchan()
+ sendprec()
+}
+
+func chanchan() {
+ cc := make(chan chan int, 1)
+ c := make(chan int, 1)
+ cc <- c
+ select {
+ case <-cc <- 2:
+ default:
+ panic("nonblock")
+ }
+ if <-c != 2 {
+ panic("bad receive")
+ }
+}
+
+func sendprec() {
+ c := make(chan bool, 1)
+ c <- false || true // not a syntax error: same as c <- (false || true)
+ if !<-c {
+ panic("sent false")
+ }
+}
println("newfunc returned broken funcs")
panic("fail")
}
+
+ ff(1)
+}
+
+func ff(x int) {
+ call(func() {
+ _ = x
+ })
+}
+
+func call(func()) {
}
}
}
+type T *int
+
func main() {
var a []int
var b map[string]int
isfalse(ib == id)
istrue(ic == id)
istrue(ie == ie)
+
+ // these are okay because one side of the
+ // comparison need only be assignable to the other.
+ isfalse(a == ib)
+ isfalse(a == ic)
+ isfalse(a == id)
+ isfalse(b == ic)
+ isfalse(b == id)
+ istrue(c == id)
+ istrue(e == ie)
+
+ isfalse(ia == b)
+ isfalse(ia == c)
+ isfalse(ia == d)
+ isfalse(ib == c)
+ isfalse(ib == d)
+ istrue(ic == d)
+ istrue(ie == e)
// 6g used to let this go through as true.
var g uint64 = 123
println("m[ic] = ", m[ic])
panic("bad m[ic]")
}
+
+ // non-interface comparisons
+ {
+ c := make(chan int)
+ c1 := (<-chan int)(c)
+ c2 := (chan<- int)(c)
+ istrue(c == c1)
+ istrue(c == c2)
+ istrue(c1 == c)
+ istrue(c2 == c)
+
+ d := make(chan int)
+ isfalse(c == d)
+ isfalse(d == c)
+ isfalse(d == c1)
+ isfalse(d == c2)
+ isfalse(c1 == d)
+ isfalse(c2 == d)
+ }
+
+ // named types vs not
+ {
+ var x = new(int)
+ var y T
+ var z T = x
+
+ isfalse(x == y)
+ istrue(x == z)
+ isfalse(y == z)
+
+ isfalse(y == x)
+ istrue(z == x)
+ isfalse(z == y)
+ }
}
--- /dev/null
+// 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 must be
+ // assignable one to the other (or vice versa)
+ // so chan int can be compared against
+ // directional channels but channel of different
+ // direction cannot be compared against each other.
+ var c1 chan <-int
+ var c2 <-chan int
+ var c3 chan int
+
+ use(c1 == c2) // ERROR "invalid operation|incompatible"
+ use(c2 == c1) // ERROR "invalid operation|incompatible"
+ use(c1 == c3)
+ use(c2 == c2)
+ use(c3 == c1)
+ use(c3 == c2)
+
+ // Same applies to named types.
+ var p1 T1
+ var p2 T2
+ var p3 *int
+
+ use(p1 == p2) // ERROR "invalid operation|incompatible"
+ use(p2 == p1) // ERROR "invalid operation|incompatible"
+ use(p1 == p3)
+ use(p2 == p2)
+ use(p3 == p1)
+ use(p3 == p2)
+
+ // Comparison of structs should have a good message
+ use(t3 == t3) // ERROR "struct|expected"
+}
if(iscnan(n) && d == 0)
q = (NAN+NAN*I) / zero;
- printf("\tTest{cmplx(%s, %s), cmplx(%s, %s), cmplx(%s, %s)},\n",
+ printf("\tTest{complex(%s, %s), complex(%s, %s), complex(%s, %s)},\n",
fmt(creal(n)), fmt(cimag(n)),
fmt(creal(d)), fmt(cimag(d)),
fmt(creal(q)), fmt(cimag(q)));
f(String) // ERROR "convert|wrong type|cannot|incompatible"
f(Bool) // ERROR "convert|wrong type|cannot|incompatible"
}
+
+const ptr = nil // ERROR "const.*nil"
println("type info didn't propagate in const: got", s)
panic("fail")
}
+ x := uint(5)
+ y := float64(uint64(1)<<x) // used to fail to compile
+ if y != 32 {
+ println("wrong y", y)
+ panic("fail")
+ }
}
var output32 = make([]uint32, N)
var input64 = make([]uint64, N)
var output64 = make([]uint64, N)
+var inputS string
+var outputS = make([]uint8, N)
+
+type my8 []uint8
+type my16 []uint16
+type my32 []uint32
+type my32b []uint32
+type my64 []uint64
+type myS string
func u8(i int) uint8 {
i = 'a' + i%26
for i := range input8 {
input8[i] = u8(in)
output8[i] = u8(out)
+ outputS[i] = u8(out)
input16[i] = u16(in)
output16[i] = u16(out)
input32[i] = u32(in)
in++
out++
}
+ inputS = string(input8)
}
func clamp(n int) int {
func doAllSlices(length, in, out int) {
reset()
- n := copy(output8[out:clamp(out+length)], input8[in:clamp(in+length)])
+ n := copy(my8(output8[out:clamp(out+length)]), input8[in:clamp(in+length)])
verify8(length, in, out, n)
- n = copy(output16[out:clamp(out+length)], input16[in:clamp(in+length)])
+ n = copy(my8(outputS[out:clamp(out+length)]), myS(inputS[in:clamp(in+length)]))
+ verifyS(length, in, out, n)
+ n = copy(my16(output16[out:clamp(out+length)]), input16[in:clamp(in+length)])
verify16(length, in, out, n)
- n = copy(output32[out:clamp(out+length)], input32[in:clamp(in+length)])
+ n = copy(my32(output32[out:clamp(out+length)]), my32b(input32[in:clamp(in+length)]))
verify32(length, in, out, n)
- n = copy(output64[out:clamp(out+length)], input64[in:clamp(in+length)])
+ n = copy(my64(output64[out:clamp(out+length)]), input64[in:clamp(in+length)])
verify64(length, in, out, n)
}
}
}
+func badS(state string, i, length, in, out int) {
+ fmt.Printf("%s bad(%d %d %d): %c not %c:\n\t%s\n\t%s\n",
+ state,
+ length, in, out,
+ outputS[i],
+ uint8(i+13),
+ inputS, outputS)
+ os.Exit(1)
+}
+
+func verifyS(length, in, out, m int) {
+ n := ncopied(length, in, out)
+ if m != n {
+ fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n)
+ return
+ }
+ // before
+ var i int
+ for i = 0; i < out; i++ {
+ if outputS[i] != u8(i+13) {
+ badS("beforeS", i, length, in, out)
+ return
+ }
+ }
+ // copied part
+ for ; i < out+n; i++ {
+ if outputS[i] != u8(i+in-out) {
+ badS("copiedS", i, length, in, out)
+ return
+ }
+ }
+ // after
+ for ; i < len(outputS); i++ {
+ if outputS[i] != u8(i+13) {
+ badS("afterS", i, length, in, out)
+ return
+ }
+ }
+}
+
func bad16(state string, i, length, in, out int) {
fmt.Printf("%s bad(%d %d %d): %x not %x:\n\t%v\n\t%v\n",
state,
package main
+import "unsafe"
+
func sum(args ...int) int { return 0 }
var (
_ = funny(nil, nil)
_ = funny([]T{}) // ok because []T{} is a T; passes []T{[]T{}}
)
+
+func bad(args ...int) {
+ print(1, 2, args...) // ERROR "[.][.][.]"
+ println(args...) // ERROR "[.][.][.]"
+ ch := make(chan int)
+ close(ch...) // ERROR "[.][.][.]"
+ _ = len(args...) // ERROR "[.][.][.]"
+ _ = new(int...) // ERROR "[.][.][.]"
+ n := 10
+ _ = make([]byte, n...) // ERROR "[.][.][.]"
+ // TODO(rsc): enable after gofmt bug is fixed
+ // _ = make([]byte, 10 ...) // error "[.][.][.]"
+ var x int
+ _ = unsafe.Pointer(&x...) // ERROR "[.][.][.]"
+ _ = unsafe.Sizeof(x...) // ERROR "[.][.][.]"
+}
}
}
-func addDotDotDot(v ...interface{}) { result += fmt.Sprint(v) }
+func addDotDotDot(v ...interface{}) { result += fmt.Sprint(v...) }
func test2helper() {
for i := 0; i < 10; i++ {
-// [ $GOOS != nacl ] || exit 0 # NaCl runner does not expose environment
// $G $F.go && $L $F.$A && ./$A.out
// Copyright 2009 The Go Authors. All rights reserved.
--- /dev/null
+// $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.
+
+// No newline at the end of this file.
+
+package main
\ No newline at end of file
--- /dev/null
+// $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
+
+// No newline at the end of this comment.
\ No newline at end of file
# Use of this source code is governed by a BSD-style
# license that can be found in the LICENSE file.
-# This script checks that the compilers emits the errors which we
-# expect. Usage: errchk COMPILER [OPTS] SOURCEFILE. This will run
-# the command COMPILER [OPTS] SOURCEFILE. The compilation is expected
-# to fail; if it succeeds, this script will report an error. The
-# stderr output of the compiler will be matched against comments in
-# SOURCEFILE. For each line of the source file which should generate
-# an error, there should be a comment of the form // ERROR "regexp".
-# If the compiler generates an error for a line which has no such
-# commnt, this script will report an error. Likewise if the compiler
-# does not generate an error for a line which has a comment, or if the
-# error message does not match the <regexp>. The <regexp> syntax
-# is Perl but its best to stick to egrep.
+# This script checks that the compilers emit the errors which we expect.
+# Usage: errchk COMPILER [OPTS] SOURCEFILES. This will run the command
+# COMPILER [OPTS] SOURCEFILES. The compilation is expected to fail; if
+# it succeeds, this script will report an error. The stderr output of
+# the compiler will be matched against comments in SOURCEFILES. For each
+# line of the source files which should generate an error, there should
+# be a comment of the form // ERROR "regexp". If the compiler generates
+# an error for a line which has no such comment, this script will report
+# an error. Likewise if the compiler does not generate an error for a
+# line which has a comment, or if the error message does not match the
+# <regexp>. The <regexp> syntax is Perl but its best to stick to egrep.
use POSIX;
if(@ARGV < 1) {
- print STDERR "Usage: errchk COMPILER [OPTS] SOURCEFILE\n";
+ print STDERR "Usage: errchk COMPILER [OPTS] SOURCEFILES\n";
exit 1;
}
-$file = $ARGV[@ARGV-1];
-open(SRC, $file) || die "BUG: errchk: open $file: $!";
-@src = <SRC>;
-close(SRC);
+# Grab SOURCEFILES
+foreach(reverse 0 .. @ARGV-1) {
+ unless($ARGV[$_] =~ /\.go$/) {
+ @file = @ARGV[$_+1 .. @ARGV-1];
+ last;
+ }
+}
+
+foreach $file (@file) {
+ open(SRC, $file) || die "BUG: errchk: open $file: $!";
+ $src{$file} = [<SRC>];
+ close(SRC);
+}
# Run command
$cmd = join(' ', @ARGV);
}
}
-$line = 0;
-foreach $src (@src) {
- $line++;
- next unless $src =~ m|// (GC_)?ERROR (.*)|;
- $regexp = $2;
- if($regexp !~ /^"([^"]*)"/) {
- print STDERR "$file:$line: malformed regexp\n";
- next;
- }
- $regexp = $1;
-
- @errmsg = grep { /$file:$line:/ } @out;
- @out = grep { !/$file:$line:/ } @out;
- if(@errmsg == 0) {
- bug();
- print STDERR "errchk: $file:$line: missing expected error: '$regexp'\n";
- next;
- }
- @match = grep { /$regexp/ } @errmsg;
- if(@match == 0) {
- bug();
- print STDERR "errchk: $file:$line: error message does not match '$regexp'\n";
- next;
+sub chk {
+ my $file = shift;
+ my $line = 0;
+ my $regexp;
+ my @errmsg;
+ my @match;
+ foreach my $src (@{$src{$file}}) {
+ $line++;
+ next if $src =~ m|////|; # double comment disables ERROR
+ next unless $src =~ m|// (GC_)?ERROR (.*)|;
+ $regexp = $2;
+ if($regexp !~ /^"([^"]*)"/) {
+ print STDERR "$file:$line: malformed regexp\n";
+ next;
+ }
+ $regexp = $1;
+
+ @errmsg = grep { /$file:$line[:[]/ } @out;
+ @out = grep { !/$file:$line[:[]/ } @out;
+ if(@errmsg == 0) {
+ bug();
+ print STDERR "errchk: $file:$line: missing expected error: '$regexp'\n";
+ next;
+ }
+ @match = grep { /$regexp/ } @errmsg;
+ if(@match == 0) {
+ bug();
+ print STDERR "errchk: $file:$line: error message does not match '$regexp'\n";
+ next;
+ }
}
}
+foreach $file (@file) {
+ chk($file)
+}
+
if(@out != 0) {
bug();
- print STDERR "errchk: $file: unmatched error messages:\n";
+ print STDERR "errchk: unmatched error messages:\n";
print STDERR "==================================================\n";
print STDERR @out;
print STDERR "==================================================\n";
-// ! $G $D/$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
package main
func main() {
- var i int = 100;
- i = i << -3; // BUG: should not compile (negative shift)
+ var i int = 100
+ i = i << -3 // ERROR "overflows|negative"
}
/*
package main
func main() {
- //TODO(rsc): uncomment when this syntax is valid for receive+check closed
- // c := make(chan int);
- // ok := false;
- // var i int;
- //
- // i, ok = <-c; // works
- // _, _ = i, ok;
- //
- // ca := new([2]chan int);
- // i, ok = <-(ca[0]); // fails: c.go:11: bad shape across assignment - cr=1 cl=2
- // _, _ = i, ok;
+ c := make(chan int);
+ ok := false;
+ var i int;
+
+ i, ok = <-c; // works
+ _, _ = i, ok;
+
+ ca := new([2]chan int);
+ i, ok = <-(ca[0]); // fails: c.go:11: bad shape across assignment - cr=1 cl=2
+ _, _ = i, ok;
}
-// ! $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
// license that can be found in the LICENSE file.
-package main
-
-const x x = 2;
+package main
+
+const x x = 2 // ERROR "loop|type"
/*
bug081.go:3: first constant must evaluate an expression
--- /dev/null
+// $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.
+
+package main
+
+const (
+ joao = "João"
+ jose = "José"
+)
+
+func main() {
+ s1 := joao
+ s2 := jose
+ if (s1 < s2) != (joao < jose) {
+ panic("unequal")
+ }
+}
func multi() (int, int) { return 1, 2 }
func xxx() {
- //TODO(rsc): uncomment when this syntax is valid for receive+check closed
- // var c chan int
- // x, ok := <-c
+ var c chan int
+ x, ok := <-c
var m map[int]int
- x, ok := m[1]
+ x, ok = m[1]
var i interface{}
var xx int
package main
func main() {
- //TODO(rsc): uncomment when this syntax is valid for receive+check closed
- // c := make(chan int, 1)
- // c <- 100
- // x, ok := <-c
- // if x != 100 || !ok {
- // println("x=", x, " ok=", ok, " want 100, true")
- // panic("fail")
- // }
- // x, ok = <-c
- // if x != 0 || ok {
- // println("x=", x, " ok=", ok, " want 0, false")
- // panic("fail")
- // }
+ c := make(chan int, 1)
+ c <- 100
+ x, ok := <-c
+ if x != 100 || !ok {
+ println("x=", x, " ok=", ok, " want 100, true")
+ panic("fail")
+ }
+ close(c)
+ x, ok = <-c
+ if x != 0 || ok {
+ println("x=", x, " ok=", ok, " want 0, false")
+ panic("fail")
+ }
}
c := make(chan byte, 1)
c <- 'C'
- //TODO(rsc): uncomment when this syntax is valid for receive+check closed
// 15 16
- // *f(), p1 = <-e1(c, 16)
- *f(), p1 = <-e1(c, 16), true // delete uncommenting above
+ *f(), p1 = <-e1(c, 16)
+ close(c)
// 17 18
- // *f(), p2 = <-e1(c, 18)
- *f(), p2, _ = 0, false, e1(c, 18) // delete when uncommenting above
+ *f(), p2 = <-e1(c, 18)
a[17] += '0'
if !p1 || p2 {
println("bad chan check", i, p1, p2)
-// [ $GOOS != nacl ] || exit 0 # no network
// $G $D/$F.go && $L $F.$A && ./$A.out
// Copyright 2010 The Go Authors. All rights reserved.
}
func g(args ...interface{}) {
- f(args) // ERROR "[.][.][.]|incompatible"
+ f(args) // ERROR "cannot use|incompatible"
}
--- /dev/null
+// $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(os.Args) > 1
+ status := 0
+ var b1 [10]T1
+ a0, _ := strconv.Btoui64(fmt.Sprintf("%p", &b1[0])[2:], 16)
+ a1, _ := strconv.Btoui64(fmt.Sprintf("%p", &b1[1])[2:], 16)
+ if a1 != a0+1 {
+ fmt.Println("FAIL")
+ if report {
+ fmt.Println("alignment should be 1, is", a1-a0)
+ }
+ status = 1
+ }
+ var b2 [10]T2
+ a0, _ = strconv.Btoui64(fmt.Sprintf("%p", &b2[0])[2:], 16)
+ a1, _ = strconv.Btoui64(fmt.Sprintf("%p", &b2[1])[2:], 16)
+ if a1 != a0+2 {
+ if status == 0 {
+ fmt.Println("FAIL")
+ status = 1
+ }
+ if report {
+ fmt.Println("alignment should be 2, is", a1-a0)
+ }
+ }
+ var b4 [10]T4
+ a0, _ = strconv.Btoui64(fmt.Sprintf("%p", &b4[0])[2:], 16)
+ a1, _ = strconv.Btoui64(fmt.Sprintf("%p", &b4[1])[2:], 16)
+ if a1 != a0+4 {
+ if status == 0 {
+ fmt.Println("FAIL")
+ status = 1
+ }
+ if report {
+ fmt.Println("alignment should be 4, is", a1-a0)
+ }
+ }
+ os.Exit(status)
+}
--- /dev/null
+// 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 should be reported on line 24.
+var a int = "bogus"
+
+// Line 15 of file.
+// 16
+// 17
+// 18
+// 19
+// 20
+// 21
+// 22
+// 23
+// ERROR "cannot|incompatible"
--- /dev/null
+// 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 p1
+
+type T <-chan int
+var x = make(chan T)
+
--- /dev/null
+// 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 p2
+
+import _ "./p1"
+
--- /dev/null
+// $G $D/$F.dir/p1.go && $G $D/$F.dir/p2.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.
+
+ignored
--- /dev/null
+// $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() {
+ var f float64
+ _ = complex(1/f, 0)
+}
--- /dev/null
+// $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.
+
+// issue 1136
+
+package main
+
+import "fmt"
+
+func log1(f string, argv ...interface{}) {
+ fmt.Printf("log: %s\n", fmt.Sprintf(f, argv...))
+}
+
+func main() {
+ log1("%d", 42)
+}
--- /dev/null
+// $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.
+
+// issue 1016
+
+package main
+
+func foo(t interface{}, c chan int) {
+ switch v := t.(type) {
+ case int:
+ select {
+ case <-c:
+ // bug was: internal compiler error: var without type, init: v
+ }
+ }
+}
--- /dev/null
+// 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 p
+
+import (
+ "bytes"
+ "fmt"
+)
+
+type t int
+
+func main() {
+ _ = t.bar // ERROR "no method"
+ var b bytes.Buffer
+ fmt.Print(b) // ERROR "implicit assignment"
+}
--- /dev/null
+// $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
+
+func main() {
+ m := make(map[string][1000]byte)
+ m["hi"] = [1000]byte{1}
+
+ v := m["hi"]
+
+ for k, vv := range m {
+ if k != "hi" || string(v[:]) != string(vv[:]) {
+ panic("bad iter")
+ }
+ }
+}
--- /dev/null
+// $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.
+
+// issue 1172
+
+package main
+
+func main() {
+ var i interface{}
+ c := make(chan int, 1)
+ c <- 1
+ select {
+ case i = <-c: // error on this line
+ }
+ if i != 1 {
+ println("bad i", i)
+ panic("BUG")
+ }
+}
--- /dev/null
+// 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"
+
+func a() {
+ fmt.DoesNotExist() // ERROR "undefined"
+}
--- /dev/null
+// 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"
+
+func b() {
+ Println()
+}
--- /dev/null
+// errchk $G -e $D/$F.dir/[ab].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.
+
+// Issue 1284
+
+package bug313
+
+/*
+6g bug313.dir/[ab].go
+
+Before:
+bug313.dir/b.go:7: internal compiler error: fault
+
+Now:
+bug313.dir/a.go:10: undefined: fmt.DoesNotExist
+*/
--- /dev/null
+// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug314
+
+// 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 call wrong methods; issue 1290.
+
+package main
+
+type S struct {
+}
+func (S) a() int{
+ return 0
+}
+func (S) b() int{
+ return 1
+}
+
+func main() {
+ var i interface {
+ b() int
+ a() int
+ } = S{}
+ if i.a() != 0 {
+ panic("wrong method called")
+ }
+ if i.b() != 1 {
+ panic("wrong method called")
+ }
+}
--- /dev/null
+// $G $D/$F.go || echo BUG: bug315
+
+// 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 1368.
+
+package main
+
+func main() {
+ a := complex(2, 2)
+ a /= 2
+}
+
+/*
+bug315.go:13: internal compiler error: optoas: no entry DIV-complex
+*/
--- /dev/null
+// $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) // was: const initializer must be constant
+)
+
+func main() {}
--- /dev/null
+// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug317
+
+// 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
+
+func main() {
+ x := []uint{0}
+ x[0] &^= f()
+}
+
+func f() uint {
+ return 1<<31 // doesn't panic with 1<<31 - 1
+}
--- /dev/null
+// 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"
--- /dev/null
+// $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
+
+import "unsafe"
+
+func main() {
+ var x int
+
+ a := uint64(uintptr(unsafe.Pointer(&x)))
+ b := uint32(uintptr(unsafe.Pointer(&x)))
+ c := uint16(uintptr(unsafe.Pointer(&x)))
+ d := int64(uintptr(unsafe.Pointer(&x)))
+ e := int32(uintptr(unsafe.Pointer(&x)))
+ f := int16(uintptr(unsafe.Pointer(&x)))
+
+ _, _, _, _, _, _ = a, b, c, d, e, f
+}
--- /dev/null
+// $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.
+
+package main
+
+func main() {
+ c := make(chan int, 1)
+ dummy := make(chan int)
+ v := 0x12345678
+ for i := 0; i < 10; i++ {
+ // 6g had a bug that caused select to pass &t to
+ // selectrecv before allocating the memory for t,
+ // which caused non-deterministic crashes.
+ // This test looks for the bug by checking that the
+ // value received actually ends up in t.
+ // If the allocation happens after storing through
+ // whatever garbage &t holds, the later reference
+ // to t in the case body will use the new pointer and
+ // not see the received value.
+ v += 0x1020304
+ c <- v
+ select {
+ case t := <-c:
+ go func() {
+ f(t)
+ }()
+ escape(&t)
+ if t != v {
+ println(i, v, t)
+ panic("wrong values")
+ }
+ case dummy <- 1:
+ }
+ }
+}
+
+func escape(*int) {
+}
+
+func f(int) {
+}
+
--- /dev/null
+// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug321
+
+// 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.
+
+// Troublesome floating point constants. Issue 1463.
+
+package main
+
+import "fmt"
+
+func check(test string, got, want float64) bool {
+ if got != want {
+ fmt.Println(test, "got", got, "want", want)
+ return false
+ }
+ return true
+}
+
+func main() {
+ good := true
+ // http://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308/
+ good = good && check("2.2250738585072012e-308", 2.2250738585072012e-308, 2.2250738585072014e-308)
+ // http://www.exploringbinary.com/php-hangs-on-numeric-value-2-2250738585072011e-308/
+ good = good && check("2.2250738585072011e-308", 2.2250738585072011e-308, 2.225073858507201e-308)
+ if !good {
+ panic("fail")
+ }
+}
--- /dev/null
+// 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() // ERROR "undefined"
+ p.Meth2() // ERROR "undefined"
+}
--- /dev/null
+// 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
+
+import "unsafe"
+
+func main() {
+ var x unsafe.Pointer
+ println(*x) // ERROR "invalid indirect.*unsafe.Pointer"
+ var _ = (unsafe.Pointer)(nil).foo // ERROR "foo"
+}
--- /dev/null
+// 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
+
+import "os"
+
+func f() (_ int, err os.Error) {
+ return
+}
+
+func g() (x int, _ os.Error) {
+ return
+}
+
+func h() (_ int, _ os.Error) {
+ return
+}
+
+func i() (int, os.Error) {
+ return // ERROR "not enough arguments to return"
+}
+
+func f1() (_ int, err os.Error) {
+ return 1, nil
+}
+
+func g1() (x int, _ os.Error) {
+ return 1, nil
+}
+
+func h1() (_ int, _ os.Error) {
+ return 1, nil
+}
+
+func ii() (int, os.Error) {
+ return 1, nil
+}
package main
-import "os"
-
-var deLim float64
var bad bool
-func
-init() {
- if os.Getenv("GOARCH") == "arm" {
- deLim = 1.0e-8
- } else {
- deLim = 10.e-14
+func pow10(pow int) float64 {
+ if pow < 0 {
+ return 1 / pow10(-pow)
+ }
+ if pow > 0 {
+ return pow10(pow-1) * 10
}
-}
-
-func
-pow10(pow int) float64 {
- if pow < 0 { return 1/pow10(-pow); }
- if pow > 0 { return pow10(pow-1)*10; }
return 1
}
-func
-close(da float64, ia, ib int64, pow int) bool {
+func close(da float64, ia, ib int64, pow int) bool {
db := float64(ia) / float64(ib)
db *= pow10(pow)
return false
}
- de := (da-db) /da
+ de := (da - db) / da
if de < 0 {
de = -de
}
- if de < deLim {
+ if de < 1e-14 {
return true
}
if !bad {
return false
}
-func
-main() {
- if !close(0., 0, 1, 0) { print("0. is ", 0., "\n"); }
- if !close(+10., 10, 1, 0) { print("+10. is ", +10., "\n"); }
- if !close(-210., -210, 1, 0) { print("-210. is ", -210., "\n"); }
+func main() {
+ if !close(0., 0, 1, 0) {
+ print("0. is ", 0., "\n")
+ }
+ if !close(+10., 10, 1, 0) {
+ print("+10. is ", +10., "\n")
+ }
+ if !close(-210., -210, 1, 0) {
+ print("-210. is ", -210., "\n")
+ }
- if !close(.0, 0, 1, 0) { print(".0 is ", .0, "\n"); }
- if !close(+.01, 1, 100, 0) { print("+.01 is ", +.01, "\n"); }
- if !close(-.012, -12, 1000, 0) { print("-.012 is ", -.012, "\n"); }
+ if !close(.0, 0, 1, 0) {
+ print(".0 is ", .0, "\n")
+ }
+ if !close(+.01, 1, 100, 0) {
+ print("+.01 is ", +.01, "\n")
+ }
+ if !close(-.012, -12, 1000, 0) {
+ print("-.012 is ", -.012, "\n")
+ }
- if !close(0.0, 0, 1, 0) { print("0.0 is ", 0.0, "\n"); }
- if !close(+10.01, 1001, 100, 0) { print("+10.01 is ", +10.01, "\n"); }
- if !close(-210.012, -210012, 1000, 0) { print("-210.012 is ", -210.012, "\n"); }
+ if !close(0.0, 0, 1, 0) {
+ print("0.0 is ", 0.0, "\n")
+ }
+ if !close(+10.01, 1001, 100, 0) {
+ print("+10.01 is ", +10.01, "\n")
+ }
+ if !close(-210.012, -210012, 1000, 0) {
+ print("-210.012 is ", -210.012, "\n")
+ }
- if !close(0E+1, 0, 1, 0) { print("0E+1 is ", 0E+1, "\n"); }
- if !close(+10e2, 10, 1, 2) { print("+10e2 is ", +10e2, "\n"); }
- if !close(-210e3, -210, 1, 3) { print("-210e3 is ", -210e3, "\n"); }
+ if !close(0E+1, 0, 1, 0) {
+ print("0E+1 is ", 0E+1, "\n")
+ }
+ if !close(+10e2, 10, 1, 2) {
+ print("+10e2 is ", +10e2, "\n")
+ }
+ if !close(-210e3, -210, 1, 3) {
+ print("-210e3 is ", -210e3, "\n")
+ }
- if !close(0E-1, 0, 1, 0) { print("0E-1 is ", 0E-1, "\n"); }
- if !close(+0e23, 0, 1, 1) { print("+0e23 is ", +0e23, "\n"); }
- if !close(-0e345, 0, 1, 1) { print("-0e345 is ", -0e345, "\n"); }
+ if !close(0E-1, 0, 1, 0) {
+ print("0E-1 is ", 0E-1, "\n")
+ }
+ if !close(+0e23, 0, 1, 1) {
+ print("+0e23 is ", +0e23, "\n")
+ }
+ if !close(-0e345, 0, 1, 1) {
+ print("-0e345 is ", -0e345, "\n")
+ }
- if !close(0E1, 0, 1, 1) { print("0E1 is ", 0E1, "\n"); }
- if !close(+10e23, 10, 1, 23) { print("+10e23 is ", +10e23, "\n"); }
- if !close(-210e34, -210, 1, 34) { print("-210e34 is ", -210e34, "\n"); }
+ if !close(0E1, 0, 1, 1) {
+ print("0E1 is ", 0E1, "\n")
+ }
+ if !close(+10e23, 10, 1, 23) {
+ print("+10e23 is ", +10e23, "\n")
+ }
+ if !close(-210e34, -210, 1, 34) {
+ print("-210e34 is ", -210e34, "\n")
+ }
- if !close(0.E1, 0, 1, 1) { print("0.E1 is ", 0.E1, "\n"); }
- if !close(+10.e+2, 10, 1, 2) { print("+10.e+2 is ", +10.e+2, "\n"); }
- if !close(-210.e-3, -210, 1, -3) { print("-210.e-3 is ", -210.e-3, "\n"); }
+ if !close(0.E1, 0, 1, 1) {
+ print("0.E1 is ", 0.E1, "\n")
+ }
+ if !close(+10.e+2, 10, 1, 2) {
+ print("+10.e+2 is ", +10.e+2, "\n")
+ }
+ if !close(-210.e-3, -210, 1, -3) {
+ print("-210.e-3 is ", -210.e-3, "\n")
+ }
- if !close(.0E1, 0, 1, 1) { print(".0E1 is ", .0E1, "\n"); }
- if !close(+.01e2, 1, 100, 2) { print("+.01e2 is ", +.01e2, "\n"); }
- if !close(-.012e3, -12, 1000, 3) { print("-.012e3 is ", -.012e3, "\n"); }
+ if !close(.0E1, 0, 1, 1) {
+ print(".0E1 is ", .0E1, "\n")
+ }
+ if !close(+.01e2, 1, 100, 2) {
+ print("+.01e2 is ", +.01e2, "\n")
+ }
+ if !close(-.012e3, -12, 1000, 3) {
+ print("-.012e3 is ", -.012e3, "\n")
+ }
- if !close(0.0E1, 0, 1, 0) { print("0.0E1 is ", 0.0E1, "\n"); }
- if !close(+10.01e2, 1001, 100, 2) { print("+10.01e2 is ", +10.01e2, "\n"); }
- if !close(-210.012e3, -210012, 1000, 3) { print("-210.012e3 is ", -210.012e3, "\n"); }
+ if !close(0.0E1, 0, 1, 0) {
+ print("0.0E1 is ", 0.0E1, "\n")
+ }
+ if !close(+10.01e2, 1001, 100, 2) {
+ print("+10.01e2 is ", +10.01e2, "\n")
+ }
+ if !close(-210.012e3, -210012, 1000, 3) {
+ print("-210.012e3 is ", -210.012e3, "\n")
+ }
- if !close(0.E+12, 0, 1, 0) { print("0.E+12 is ", 0.E+12, "\n"); }
- if !close(+10.e23, 10, 1, 23) { print("+10.e23 is ", +10.e23, "\n"); }
- if !close(-210.e33, -210, 1, 33) { print("-210.e33 is ", -210.e33, "\n"); }
+ if !close(0.E+12, 0, 1, 0) {
+ print("0.E+12 is ", 0.E+12, "\n")
+ }
+ if !close(+10.e23, 10, 1, 23) {
+ print("+10.e23 is ", +10.e23, "\n")
+ }
+ if !close(-210.e33, -210, 1, 33) {
+ print("-210.e33 is ", -210.e33, "\n")
+ }
- if !close(.0E-12, 0, 1, 0) { print(".0E-12 is ", .0E-12, "\n"); }
- if !close(+.01e23, 1, 100, 23) { print("+.01e23 is ", +.01e23, "\n"); }
- if !close(-.012e34, -12, 1000, 34) { print("-.012e34 is ", -.012e34, "\n"); }
+ if !close(.0E-12, 0, 1, 0) {
+ print(".0E-12 is ", .0E-12, "\n")
+ }
+ if !close(+.01e23, 1, 100, 23) {
+ print("+.01e23 is ", +.01e23, "\n")
+ }
+ if !close(-.012e34, -12, 1000, 34) {
+ print("-.012e34 is ", -.012e34, "\n")
+ }
- if !close(0.0E12, 0, 1, 12) { print("0.0E12 is ", 0.0E12, "\n"); }
- if !close(+10.01e23, 1001, 100, 23) { print("+10.01e23 is ", +10.01e23, "\n"); }
- if !close(-210.012e33, -210012, 1000, 33) { print("-210.012e33 is ", -210.012e33, "\n"); }
+ if !close(0.0E12, 0, 1, 12) {
+ print("0.0E12 is ", 0.0E12, "\n")
+ }
+ if !close(+10.01e23, 1001, 100, 23) {
+ print("+10.01e23 is ", +10.01e23, "\n")
+ }
+ if !close(-210.012e33, -210012, 1000, 33) {
+ print("-210.012e33 is ", -210.012e33, "\n")
+ }
- if !close(0.E123, 0, 1, 123) { print("0.E123 is ", 0.E123, "\n"); }
- if !close(+10.e+23, 10, 1, 23) { print("+10.e+234 is ", +10.e+234, "\n"); }
- if !close(-210.e-35, -210, 1, -35) { print("-210.e-35 is ", -210.e-35, "\n"); }
+ if !close(0.E123, 0, 1, 123) {
+ print("0.E123 is ", 0.E123, "\n")
+ }
+ if !close(+10.e+23, 10, 1, 23) {
+ print("+10.e+234 is ", +10.e+234, "\n")
+ }
+ if !close(-210.e-35, -210, 1, -35) {
+ print("-210.e-35 is ", -210.e-35, "\n")
+ }
- if !close(.0E123, 0, 1, 123) { print(".0E123 is ", .0E123, "\n"); }
- if !close(+.01e29, 1, 100, 29) { print("+.01e29 is ", +.01e29, "\n"); }
- if !close(-.012e29, -12, 1000, 29) { print("-.012e29 is ", -.012e29, "\n"); }
+ if !close(.0E123, 0, 1, 123) {
+ print(".0E123 is ", .0E123, "\n")
+ }
+ if !close(+.01e29, 1, 100, 29) {
+ print("+.01e29 is ", +.01e29, "\n")
+ }
+ if !close(-.012e29, -12, 1000, 29) {
+ print("-.012e29 is ", -.012e29, "\n")
+ }
- if !close(0.0E123, 0, 1, 123) { print("0.0E123 is ", 0.0E123, "\n"); }
- if !close(+10.01e31, 1001, 100, 31) { print("+10.01e31 is ", +10.01e31, "\n"); }
- if !close(-210.012e19, -210012, 1000, 19) { print("-210.012e19 is ", -210.012e19, "\n"); }
+ if !close(0.0E123, 0, 1, 123) {
+ print("0.0E123 is ", 0.0E123, "\n")
+ }
+ if !close(+10.01e31, 1001, 100, 31) {
+ print("+10.01e31 is ", +10.01e31, "\n")
+ }
+ if !close(-210.012e19, -210012, 1000, 19) {
+ print("-210.012e19 is ", -210.012e19, "\n")
+ }
}
all: $(addsuffix .out, $(ALL))
-%.$O: %.go
- $(GC) $*.go
+%.$O: %.go stats.go
+ $(GC) $*.go stats.go
%.out: %.$O
$(LD) -o $@ $*.$O
"fmt"
"go/ast"
"go/parser"
+ "go/token"
"os"
"path"
"runtime"
"strings"
"time"
+ "http"
+ _ "http/pprof"
+ "log"
)
+var serve = flag.String("serve", "", "serve http on this address at end")
+
func isGoFile(dir *os.FileInfo) bool {
return dir.IsRegular() &&
!strings.HasPrefix(dir.Name, ".") && // ignore .files
}
func pkgName(filename string) string {
- file, err := parser.ParseFile(filename, nil, parser.PackageClauseOnly)
+ file, err := parser.ParseFile(token.NewFileSet(), filename, nil, parser.PackageClauseOnly)
if err != nil || file == nil {
return ""
}
}
// get package AST
- pkgs, err := parser.ParseDir(dirpath, filter, parser.ParseComments)
+ pkgs, err := parser.ParseDir(token.NewFileSet(), dirpath, filter, parser.ParseComments)
if err != nil {
println("parse", dirpath, err.String())
panic("fail")
}
func main() {
+ runtime.GOMAXPROCS(4)
+ go func() {}()
+ go func() {}()
+ go func() {}()
st := &runtime.MemStats
+ packages = append(packages, packages...)
+ packages = append(packages, packages...)
n := flag.Int("n", 4, "iterations")
p := flag.Int("p", len(packages), "# of packages to keep in memory")
flag.BoolVar(&st.DebugGC, "d", st.DebugGC, "print GC debugging info (pause times)")
flag.Parse()
+ var lastParsed []map[string]*ast.Package
var t0 int64
pkgroot := runtime.GOROOT() + "/src/pkg/"
for pass := 0; pass < 2; pass++ {
// than the normal pauses and would otherwise make
// the average look much better than it actually is.
st.NumGC = 0
- st.PauseNs = 0
+ st.PauseTotalNs = 0
t0 = time.Nanoseconds()
for i := 0; i < *n; i++ {
for j := range parsed {
parsed[j] = parseDir(pkgroot + packages[j%len(packages)])
}
+ if i+1 == *n && *serve != "" {
+ lastParsed = parsed
+ }
}
runtime.GC()
+ runtime.GC()
}
t1 := time.Nanoseconds()
fmt.Printf("Alloc=%d/%d Heap=%d Mallocs=%d PauseTime=%.3f/%d = %.3f\n",
st.Alloc, st.TotalAlloc,
st.Sys,
- st.Mallocs, float64(st.PauseNs)/1e9,
- st.NumGC, float64(st.PauseNs)/1e9/float64(st.NumGC))
-
- fmt.Printf("%10s %10s %10s\n", "size", "#alloc", "#free")
- for _, s := range st.BySize {
- fmt.Printf("%10d %10d %10d\n", s.Size, s.Mallocs, s.Frees)
- }
+ st.Mallocs, float64(st.PauseTotalNs)/1e9,
+ st.NumGC, float64(st.PauseTotalNs)/1e9/float64(st.NumGC))
+ /*
+ fmt.Printf("%10s %10s %10s\n", "size", "#alloc", "#free")
+ for _, s := range st.BySize {
+ fmt.Printf("%10d %10d %10d\n", s.Size, s.Mallocs, s.Frees)
+ }
+ */
// Standard gotest benchmark output, collected by build dashboard.
- fmt.Printf("garbage.BenchmarkParser %d %d ns/op\n", *n, (t1-t0)/int64(*n))
- fmt.Printf("garbage.BenchmarkParserPause %d %d ns/op\n", st.NumGC, int64(st.PauseNs)/int64(st.NumGC))
+ gcstats("BenchmarkParser", *n, t1-t0)
+
+ if *serve != "" {
+ log.Fatal(http.ListenAndServe(*serve, nil))
+ println(lastParsed)
+ }
}
"math",
"mime",
"net",
- "nntp",
"os",
"os/signal",
"patch",
"runtime",
"scanner",
"sort",
+ "smtp",
"strconv",
"strings",
"sync",
func main() {
- st := &runtime.MemStats
t0 := time.Nanoseconds()
verify()
for i := 0; i <= 9; i++ {
runtime.GC()
t1 := time.Nanoseconds()
- fmt.Printf("garbage.BenchmarkPeano 1 %d ns/op\n", t1-t0)
- fmt.Printf("garbage.BenchmarkPeanoPause %d %d ns/op\n", st.NumGC, int64(st.PauseNs)/int64(st.NumGC))
+ gcstats("BenchmarkPeano", 1, t1-t0)
}
--- /dev/null
+// 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"
+)
+
+func gcstats(name string, n int, t int64) {
+ st := &runtime.MemStats
+ fmt.Printf("garbage.%sMem Alloc=%d/%d Heap=%d NextGC=%d Mallocs=%d\n", name, st.Alloc, st.TotalAlloc, st.Sys, st.NextGC, st.Mallocs)
+ fmt.Printf("garbage.%s %d %d ns/op\n", name, n, t/int64(n))
+ fmt.Printf("garbage.%sLastPause 1 %d ns/op\n", name, st.PauseNs[(st.NumGC-1)%uint32(len(st.PauseNs))])
+ fmt.Printf("garbage.%sPause %d %d ns/op\n", name, st.NumGC, int64(st.PauseTotalNs)/int64(st.NumGC))
+ nn := int(st.NumGC)
+ if nn >= len(st.PauseNs) {
+ nn = len(st.PauseNs)
+ }
+ t1, t2, t3, t4, t5 := tukey5(st.PauseNs[0:nn])
+ fmt.Printf("garbage.%sPause5: %d %d %d %d %d\n", name, t1, t2, t3, t4, t5)
+
+// fmt.Printf("garbage.%sScan: %v\n", name, st.ScanDist)
+}
+
+type T []uint64
+func (t T) Len() int { return len(t) }
+func (t T) Swap(i, j int) { t[i], t[j] = t[j], t[i] }
+func (t T) Less(i, j int) bool { return t[i] < t[j] }
+
+func tukey5(raw []uint64) (lo, q1, q2, q3, hi uint64) {
+ x := make(T, len(raw))
+ copy(x, raw)
+ sort.Sort(T(x))
+ lo = x[0]
+ q1 = x[len(x)/4]
+ q2 = x[len(x)/2]
+ q3 = x[len(x)*3/4]
+ hi = x[len(x)-1]
+ return
+}
import (
"flag"
"fmt"
- "runtime"
"time"
)
fmt.Printf("long lived tree of depth %d\t check: %d\n", maxDepth, longLivedTree.itemCheck())
t1 := time.Nanoseconds()
- st := &runtime.MemStats
// Standard gotest benchmark output, collected by build dashboard.
- fmt.Printf("garbage.BenchmarkTree %d %d ns/op\n", *n, (t1-t0)/int64(*n))
- fmt.Printf("garbage.BenchmarkTreePause %d %d ns/op\n", st.NumGC, int64(st.PauseNs)/int64(st.NumGC))
-
+ gcstats("BenchmarkTree", *n, t1-t0)
}
+++ /dev/null
-
-=========== ./cmp2.go
-panic: runtime error: comparing uncomparable type []int
-
-panic PC=xxx
-
-=========== ./cmp3.go
-panic: runtime error: comparing uncomparable type []int
-
-panic PC=xxx
-
-=========== ./cmp4.go
-panic: runtime error: hash of unhashable type []int
-
-panic PC=xxx
-
-=========== ./cmp5.go
-panic: runtime error: hash of unhashable type []int
-
-panic PC=xxx
-
-=========== ./deferprint.go
-printing: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
-42 true false true +1.500000e+000 world 0x0 [0/0]0x0 0x0 0x0 255
-
-=========== ./helloworld.go
-hello, world
-
-=========== ./peano.go
-0! = 1
-1! = 1
-2! = 2
-3! = 6
-4! = 24
-5! = 120
-6! = 720
-7! = 5040
-8! = 40320
-9! = 362880
-
-=========== ./printbig.go
--9223372036854775808
-9223372036854775807
-
-=========== ./sigchld.go
-survived SIGCHLD
-
-=========== ./sinit.go
-FAIL
-
-=========== ./turing.go
-Hello World!
-
-=========== ken/intervar.go
- print 1 bio 2 file 3 -- abc
-
-=========== ken/label.go
-100
-
-=========== ken/rob1.go
-9876543210
-
-=========== ken/rob2.go
-(defn foo (add 12 34))
-
-=========== ken/simpprint.go
-hello world
-
-=========== ken/simpswitch.go
-0out01out12out2aout34out4fiveout56out6aout78out89out9
-
-=========== ken/string.go
-abcxyz-abcxyz-abcxyz-abcxyz-abcxyz-abcxyz-abcxyz
-
-=========== chan/doubleselect.go
-PASS
-
-=========== chan/nonblock.go
-PASS
-
-=========== interface/fail.go
-panic: interface conversion: *main.S is not main.I: missing method Foo
-
-panic PC=xxx
-
-=========== interface/returntype.go
-panic: interface conversion: *main.S is not main.I2: missing method Name
-
-panic PC=xxx
-
-=========== fixedbugs/bug016.go
-fixedbugs/bug016.go:11: constant -3 overflows uint
-
-=========== fixedbugs/bug027.go
-hi
-0 44444
-1 3333
-2 222
-3 11
-4 0
-0 44444
-1 3333
-2 222
-3 11
-4 0
-
-=========== fixedbugs/bug067.go
-ok
-
-=========== fixedbugs/bug070.go
-outer loop top k 0
-inner loop top i 0
-do break
-broke
-
-=========== fixedbugs/bug081.go
-fixedbugs/bug081.go:9: typechecking loop
-
-=========== fixedbugs/bug093.go
-M
-
-=========== fixedbugs/bug113.go
-panic: interface conversion: interface is int, not int32
-
-panic PC=xxx
-
-=========== fixedbugs/bug148.go
-2 3
-panic: interface conversion: interface is main.T, not main.T
-
-panic PC=xxx
=========== ./cmp2.go
panic: runtime error: comparing uncomparable type []int
-panic PC=xxx
=========== ./cmp3.go
panic: runtime error: comparing uncomparable type []int
-panic PC=xxx
=========== ./cmp4.go
panic: runtime error: hash of unhashable type []int
-panic PC=xxx
=========== ./cmp5.go
panic: runtime error: hash of unhashable type []int
-panic PC=xxx
=========== ./deferprint.go
printing: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
=========== ken/cplx3.go
(+1.292308e+000-1.384615e-001i)
(+1.292308e+000-1.384615e-001i)
-64
=========== ken/cplx4.go
c = (-5.000000-6.000000i)
=========== interface/fail.go
panic: interface conversion: *main.S is not main.I: missing method Foo
-panic PC=xxx
=========== interface/returntype.go
panic: interface conversion: *main.S is not main.I2: missing method Name
-panic PC=xxx
== nilptr/
== fixedbugs/
-=========== fixedbugs/bug016.go
-fixedbugs/bug016.go:11: constant -3 overflows uint
-
=========== fixedbugs/bug027.go
hi
0 44444
do break
broke
-=========== fixedbugs/bug081.go
-fixedbugs/bug081.go:9: typechecking loop
-
=========== fixedbugs/bug093.go
M
=========== fixedbugs/bug113.go
panic: interface conversion: interface is int, not int32
-panic PC=xxx
=========== fixedbugs/bug148.go
2 3
panic: interface conversion: interface is main.T, not main.T
-panic PC=xxx
== bugs/
-=========== bugs/bug260.go
-FAIL
-BUG: bug260 failed
+=========== bugs/bug322.go
+bugs/bug322.dir/main.go:19: implicit assignment of unexported field 'x' of lib.T in method receiver
+bugs/bug322.dir/main.go:22: implicit assignment of unexported field 'x' of lib.T in assignment
+bugs/bug322.dir/main.go:31: implicit assignment of unexported field 'x' of lib.T in method receiver
+BUG: fails incorrectly
+
+=========== bugs/bug324.go
+BUG: errchk: command succeeded unexpectedly
// $G $D/$F.go && $L $F.$A &&
-// ./$A.out -pass 0 >tmp.go && $G tmp.go && $L -o tmp1.$A tmp.$A && ./tmp1.$A &&
+// ./$A.out -pass 0 >tmp.go && $G tmp.go && $L -o $A.out1 tmp.$A && ./$A.out1 &&
// ./$A.out -pass 1 >tmp.go && errchk $G -e tmp.go &&
// ./$A.out -pass 2 >tmp.go && errchk $G -e tmp.go
-// rm -f tmp.go
+// rm -f tmp.go $A.out1
// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
--- /dev/null
+// 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.
+
+package main
+
+import "runtime"
+
+func init() {
+}
+
+func main() {
+ init() // ERROR "undefined.*init"
+ runtime.init() // ERROR "unexported.*runtime\.init"
+ var _ = init // ERROR "undefined.*init"
+}
--- /dev/null
+// 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.
+
+// Check methods derived from embedded interface and *interface values.
+
+package main
+
+import "os"
+
+const Value = 1e12
+
+type Inter interface { M() int64 }
+
+type T int64
+func (t T) M() int64 { return int64(t) }
+var t = T(Value)
+var pt = &t
+var ti Inter = t
+var pti = &ti
+
+type S struct { Inter }
+var s = S{ ti }
+var ps = &s
+
+type SP struct { *Inter } // ERROR "interface"
+
+var i Inter
+var pi = &i
+
+var ok = true
+
+func check(s string, v int64) {
+ if v != Value {
+ println(s, v)
+ ok = false
+ }
+}
+
+func main() {
+ check("t.M()", t.M())
+ check("pt.M()", pt.M())
+ check("ti.M()", ti.M())
+ check("pti.M()", pti.M()) // ERROR "method"
+ check("s.M()", s.M())
+ check("ps.M()", ps.M())
+
+ i = t
+ check("i = t; i.M()", i.M())
+ check("i = t; pi.M()", pi.M()) // ERROR "method"
+
+ i = pt
+ check("i = pt; i.M()", i.M())
+ check("i = pt; pi.M()", pi.M()) // ERROR "method"
+
+ i = s
+ check("i = s; i.M()", i.M())
+ check("i = s; pi.M()", pi.M()) // ERROR "method"
+
+ i = ps
+ check("i = ps; i.M()", i.M())
+ check("i = ps; pi.M()", pi.M()) // ERROR "method"
+
+ if !ok {
+ println("BUG: interface10")
+ os.Exit(1)
+ }
+}
--- /dev/null
+// $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.
+
+// near-exhaustive test of converting numbers between types.
+
+package main
+
+var i8 int8;
+var u8 uint8;
+var i16 int16;
+var u16 uint16;
+var i32 int32;
+var u32 uint32;
+var i64 int64;
+var u64 uint64;
+var f32 float32;
+var f64 float64;
+
+type big float64
+
+type t struct {
+ from, to int
+ val big
+}
+
+const (
+ ti8 = iota+1
+ tu8
+ ti16
+ tu16
+ ti32
+ tu32
+ ti64
+ tu64
+ tf32
+ tf64
+)
+
+var x = []t{
+
+ /* value good in all types (10) */
+ { ti8, ti8, 10 }, { ti8, tu8, 10 }, { ti8, ti16, 10 }, { ti8, tu16, 10 },
+ { ti8, ti32, 10 }, { ti8, tu32, 10 }, { ti8, ti64, 10 }, { ti8, tu64, 10 },
+ { ti8, tf32, 10 }, { ti8, tf64, 10 },
+
+ { tu8, ti8, 10 }, { tu8, tu8, 10 }, { tu8, ti16, 10 }, { tu8, tu16, 10 },
+ { tu8, ti32, 10 }, { tu8, tu32, 10 }, { tu8, ti64, 10 }, { tu8, tu64, 10 },
+ { tu8, tf32, 10 }, { tu8, tf64, 10 },
+
+ { ti16, ti8, 10 }, { ti16, tu8, 10 }, { ti16, ti16, 10 }, { ti16, tu16, 10 },
+ { ti16, ti32, 10 }, { ti16, tu32, 10 }, { ti16, ti64, 10 }, { ti16, tu64, 10 },
+ { ti16, tf32, 10 }, { ti16, tf64, 10 },
+
+ { tu16, ti8, 10 }, { tu16, tu8, 10 }, { tu16, ti16, 10 }, { tu16, tu16, 10 },
+ { tu16, ti32, 10 }, { tu16, tu32, 10 }, { tu16, ti64, 10 }, { tu16, tu64, 10 },
+ { tu16, tf32, 10 }, { tu16, tf64, 10 },
+
+ { ti32, ti8, 10 }, { ti32, tu8, 10 }, { ti32, ti16, 10 }, { ti32, tu16, 10 },
+ { ti32, ti32, 10 }, { ti32, tu32, 10 }, { ti32, ti64, 10 }, { ti32, tu64, 10 },
+ { ti32, tf32, 10 }, { ti32, tf64, 10 },
+
+ { tu32, ti8, 10 }, { tu32, tu8, 10 }, { tu32, ti16, 10 }, { tu32, tu16, 10 },
+ { tu32, ti32, 10 }, { tu32, tu32, 10 }, { tu32, ti64, 10 }, { tu32, tu64, 10 },
+ { tu32, tf32, 10 }, { tu32, tf64, 10 },
+
+ { ti64, ti8, 10 }, { ti64, tu8, 10 }, { ti64, ti16, 10 }, { ti64, tu16, 10 },
+ { ti64, ti32, 10 }, { ti64, tu32, 10 }, { ti64, ti64, 10 }, { ti64, tu64, 10 },
+ { ti64, tf32, 10 }, { ti64, tf64, 10 },
+
+ { tu64, ti8, 10 }, { tu64, tu8, 10 }, { tu64, ti16, 10 }, { tu64, tu16, 10 },
+ { tu64, ti32, 10 }, { tu64, tu32, 10 }, { tu64, ti64, 10 }, { tu64, tu64, 10 },
+ { tu64, tf32, 10 }, { tu64, tf64, 10 },
+
+ { tf32, ti8, 10 }, { tf32, tu8, 10 }, { tf32, ti16, 10 }, { tf32, tu16, 10 },
+ { tf32, ti32, 10 }, { tf32, tu32, 10 }, { tf32, ti64, 10 }, { tf32, tu64, 10 },
+ { tf32, tf32, 10 }, { tf32, tf64, 10 },
+
+ { tf64, ti8, 10 }, { tf64, tu8, 10 }, { tf64, ti16, 10 }, { tf64, tu16, 10 },
+ { tf64, ti32, 10 }, { tf64, tu32, 10 }, { tf64, ti64, 10 }, { tf64, tu64, 10 },
+ { tf64, tf32, 10 }, { tf64, tf64, 10 },
+
+ /* value good in all signed types (-4) */
+ { ti8, ti8, -4 }, { ti8, ti16, -4 },
+ { ti8, ti32, -4 }, { ti8, ti64, -4 },
+ { ti8, tf32, -4 }, { ti8, tf64, -4 },
+
+ { ti16, ti8, -4 }, { ti16, ti16, -4 },
+ { ti16, ti32, -4 }, { ti16, ti64, -4 },
+ { ti16, tf32, -4 },
+
+ { ti32, ti8, -4 }, { ti32, ti16, -4 },
+ { ti32, ti32, -4 }, { ti32, ti64, -4 },
+ { ti32, tf32, -4 }, { ti32, tf64, -4 },
+
+ { ti64, ti8, -4 }, { ti64, ti16, -4 },
+ { ti64, ti32, -4 }, { ti64, ti64, -4 },
+ { ti64, tf32, -4 },
+
+ { tf32, ti8, -4 }, { tf32, ti16, -4 },
+ { tf32, ti32, -4 }, { tf32, ti64, -4 },
+ { tf32, tf32, -4 },
+
+ { tf64, ti8, -4 }, { tf64, ti16, -4 },
+ { tf64, ti32, -4 }, { tf64, ti64, -4 },
+ { tf64, tf32, -4 }, { tf64, tf64, -4 },
+
+ /* value good in u8 and up (175) */
+ { tu8, tu8, 175 }, { tu8, ti16, 175 }, { tu8, tu16, 175 },
+ { tu8, ti32, 175 }, { tu8, tu32, 175 }, { tu8, ti64, 175 }, { tu8, tu64, 175 },
+ { tu8, tf32, 175 }, { tu8, tf64, 175 },
+
+ { ti16, tu8, 175 }, { ti16, ti16, 175 }, { ti16, tu16, 175 },
+ { ti16, ti32, 175 }, { ti16, tu32, 175 }, { ti16, ti64, 175 }, { ti16, tu64, 175 },
+ { ti16, tf32, 175 }, { ti16, tf64, 175 },
+
+ { tu16, tu8, 175 }, { tu16, ti16, 175 }, { tu16, tu16, 175 },
+ { tu16, ti32, 175 }, { tu16, tu32, 175 }, { tu16, ti64, 175 }, { tu16, tu64, 175 },
+ { tu16, tf32, 175 }, { tu16, tf64, 175 },
+
+ { ti32, tu8, 175 }, { ti32, ti16, 175 }, { ti32, tu16, 175 },
+ { ti32, ti32, 175 }, { ti32, tu32, 175 }, { ti32, ti64, 175 }, { ti32, tu64, 175 },
+ { ti32, tf32, 175 }, { ti32, tf64, 175 },
+
+ { tu32, tu8, 175 }, { tu32, ti16, 175 }, { tu32, tu16, 175 },
+ { tu32, ti32, 175 }, { tu32, tu32, 175 }, { tu32, ti64, 175 }, { tu32, tu64, 175 },
+ { tu32, tf32, 175 }, { tu32, tf64, 175 },
+
+ { ti64, tu8, 175 }, { ti64, ti16, 175 }, { ti64, tu16, 175 },
+ { ti64, ti32, 175 }, { ti64, tu32, 175 }, { ti64, ti64, 175 }, { ti64, tu64, 175 },
+ { ti64, tf32, 175 }, { ti64, tf64, 175 },
+
+ { tu64, tu8, 175 }, { tu64, ti16, 175 }, { tu64, tu16, 175 },
+ { tu64, ti32, 175 }, { tu64, tu32, 175 }, { tu64, ti64, 175 }, { tu64, tu64, 175 },
+ { tu64, tf32, 175 }, { tu64, tf64, 175 },
+
+ { tf32, tu8, 175 }, { tf32, ti16, 175 }, { tf32, tu16, 175 },
+ { tf32, ti32, 175 }, { tf32, tu32, 175 }, { tf32, ti64, 175 }, { tf32, tu64, 175 },
+ { tf32, tf32, 175 }, { tf32, tf64, 175 },
+
+ { tf64, tu8, 175 }, { tf64, ti16, 175 }, { tf64, tu16, 175 },
+ { tf64, ti32, 175 }, { tf64, tu32, 175 }, { tf64, ti64, 175 }, { tf64, tu64, 175 },
+ { tf64, tf32, 175 }, { tf64, tf64, 175 },
+
+ /* value good in u16 and up (41259) */
+ { tu16, tu16, 41259 },
+ { tu16, ti32, 41259 }, { tu16, ti64, 41259 }, { tu16, tu64, 41259 },
+ { tu16, tf32, 41259 }, { tu16, tf64, 41259 },
+
+ { ti32, tu16, 41259 },
+ { ti32, ti32, 41259 }, { ti32, tu32, 41259 }, { ti32, ti64, 41259 }, { ti32, tu64, 41259 },
+ { ti32, tf32, 41259 }, { ti32, tf64, 41259 },
+
+ { tu32, tu16, 41259 },
+ { tu32, ti32, 41259 }, { tu32, tu32, 41259 }, { tu32, ti64, 41259 }, { tu32, tu64, 41259 },
+ { tu32, tf32, 41259 }, { tu32, tf64, 41259 },
+
+ { ti64, tu16, 41259 },
+ { ti64, ti32, 41259 }, { ti64, tu32, 41259 }, { ti64, ti64, 41259 }, { ti64, tu64, 41259 },
+ { ti64, tf32, 41259 }, { ti64, tf64, 41259 },
+
+ { tu64, tu16, 41259 },
+ { tu64, ti32, 41259 }, { tu64, tu32, 41259 }, { tu64, ti64, 41259 }, { tu64, tu64, 41259 },
+ { tu64, tf32, 41259 }, { tu64, tf64, 41259 },
+
+ { tf32, tu16, 41259 },
+ { tf32, ti32, 41259 }, { tf32, tu32, 41259 }, { tf32, ti64, 41259 }, { tf32, tu64, 41259 },
+ { tf32, tf32, 41259 }, { tf32, tf64, 41259 },
+
+ { tf64, tu16, 41259 },
+ { tf64, ti32, 41259 }, { tf64, tu32, 41259 }, { tf64, ti64, 41259 }, { tf64, tu64, 41259 },
+ { tf64, tf32, 41259 }, { tf64, tf64, 41259 },
+
+ /* value good in u32 and up (3758096384) */
+ { tu32, tu32, 3758096384 }, { tu32, ti64, 3758096384 }, { tu32, tu64, 3758096384 },
+ { tu32, tf32, 3758096384 }, { tu32, tf64, 3758096384 },
+
+ { ti64, tu32, 3758096384 }, { ti64, ti64, 3758096384 }, { ti64, tu64, 3758096384 },
+ { ti64, tf32, 3758096384 }, { ti64, tf64, 3758096384 },
+
+ { tu64, tu32, 3758096384 }, { tu64, ti64, 3758096384 }, { tu64, tu64, 3758096384 },
+ { tu64, tf32, 3758096384 }, { tu64, tf64, 3758096384 },
+
+ { tf32, tu32, 3758096384 }, { tf32, ti64, 3758096384 }, { tf32, tu64, 3758096384 },
+ { tf32, tf32, 3758096384 }, { tf32, tf64, 3758096384 },
+
+ { tf64, tu32, 3758096384 }, { tf64, ti64, 3758096384 }, { tf64, tu64, 3758096384 },
+ { tf64, tf32, 3758096384 }, { tf64, tf64, 3758096384 },
+
+ /* value good in u64 and up (16717361816799281152) */
+ { tu64, tu64, 16717361816799281152 },
+ { tu64, tf32, 16717361816799281152 }, { tu64, tf64, 16717361816799281152 },
+
+ { tf32, tu64, 16717361816799281152 },
+ { tf32, tf32, 16717361816799281152 }, { tf32, tf64, 16717361816799281152 },
+
+ { tf64, tu64, 16717361816799281152 },
+ { tf64, tf32, 16717361816799281152 }, { tf64, tf64, 16717361816799281152 },
+}
+
+func main() {
+ for i:=0; i<len(x); i++ {
+ v := x[i].val // input value
+ w := big(0) // output value
+ f := x[i].from // input type
+ t := x[i].to // output type
+
+ i8 = 0; u8 = 0; i16 = 0; u16 = 0
+ i32 = 0; u32 = 0; i64 = 0; u64 = 0
+ f32 = 0; f64 = 0
+
+ switch f*100 + t {
+ default:
+ println("missing case", i, v, f, t)
+ w = v
+
+ case ti8*100 + ti8:
+ i8 = int8(v); i8 = int8(i8); w = big(i8)
+ case ti8*100 + tu8:
+ i8 = int8(v); u8 = uint8(i8); w = big(u8)
+ case ti8*100 + ti16:
+ i8 = int8(v); i16 = int16(i8); w = big(i16)
+ case ti8*100 + tu16:
+ i8 = int8(v); u16 = uint16(i8); w = big(u16)
+ case ti8*100 + ti32:
+ i8 = int8(v); i32 = int32(i8); w = big(i32)
+ case ti8*100 + tu32:
+ i8 = int8(v); u32 = uint32(i8); w = big(u32)
+ case ti8*100 + ti64:
+ i8 = int8(v); i64 = int64(i8); w = big(i64)
+ case ti8*100 + tu64:
+ i8 = int8(v); u64 = uint64(i8); w = big(u64)
+ case ti8*100 + tf32:
+ i8 = int8(v); f32 = float32(i8); w = big(f32)
+ case ti8*100 + tf64:
+ i8 = int8(v); f64 = float64(i8); w = big(f64)
+
+ case tu8*100 + ti8:
+ u8 = uint8(v); i8 = int8(u8); w = big(i8)
+ case tu8*100 + tu8:
+ u8 = uint8(v); u8 = uint8(u8); w = big(u8)
+ case tu8*100 + ti16:
+ u8 = uint8(v); i16 = int16(u8); w = big(i16)
+ case tu8*100 + tu16:
+ u8 = uint8(v); u16 = uint16(u8); w = big(u16)
+ case tu8*100 + ti32:
+ u8 = uint8(v); i32 = int32(u8); w = big(i32)
+ case tu8*100 + tu32:
+ u8 = uint8(v); u32 = uint32(u8); w = big(u32)
+ case tu8*100 + ti64:
+ u8 = uint8(v); i64 = int64(u8); w = big(i64)
+ case tu8*100 + tu64:
+ u8 = uint8(v); u64 = uint64(u8); w = big(u64)
+ case tu8*100 + tf32:
+ u8 = uint8(v); f32 = float32(u8); w = big(f32)
+ case tu8*100 + tf64:
+ u8 = uint8(v); f64 = float64(u8); w = big(f64)
+
+ case ti16*100 + ti8:
+ i16 = int16(v); i8 = int8(i16); w = big(i8)
+ case ti16*100 + tu8:
+ i16 = int16(v); u8 = uint8(i16); w = big(u8)
+ case ti16*100 + ti16:
+ i16 = int16(v); i16 = int16(i16); w = big(i16)
+ case ti16*100 + tu16:
+ i16 = int16(v); u16 = uint16(i16); w = big(u16)
+ case ti16*100 + ti32:
+ i16 = int16(v); i32 = int32(i16); w = big(i32)
+ case ti16*100 + tu32:
+ i16 = int16(v); u32 = uint32(i16); w = big(u32)
+ case ti16*100 + ti64:
+ i16 = int16(v); i64 = int64(i16); w = big(i64)
+ case ti16*100 + tu64:
+ i16 = int16(v); u64 = uint64(i16); w = big(u64)
+ case ti16*100 + tf32:
+ i16 = int16(v); f32 = float32(i16); w = big(f32)
+ case ti16*100 + tf64:
+ i16 = int16(v); f64 = float64(i16); w = big(f64)
+
+ case tu16*100 + ti8:
+ u16 = uint16(v); i8 = int8(u16); w = big(i8)
+ case tu16*100 + tu8:
+ u16 = uint16(v); u8 = uint8(u16); w = big(u8)
+ case tu16*100 + ti16:
+ u16 = uint16(v); i16 = int16(u16); w = big(i16)
+ case tu16*100 + tu16:
+ u16 = uint16(v); u16 = uint16(u16); w = big(u16)
+ case tu16*100 + ti32:
+ u16 = uint16(v); i32 = int32(u16); w = big(i32)
+ case tu16*100 + tu32:
+ u16 = uint16(v); u32 = uint32(u16); w = big(u32)
+ case tu16*100 + ti64:
+ u16 = uint16(v); i64 = int64(u16); w = big(i64)
+ case tu16*100 + tu64:
+ u16 = uint16(v); u64 = uint64(u16); w = big(u64)
+ case tu16*100 + tf32:
+ u16 = uint16(v); f32 = float32(u16); w = big(f32)
+ case tu16*100 + tf64:
+ u16 = uint16(v); f64 = float64(u16); w = big(f64)
+
+ case ti32*100 + ti8:
+ i32 = int32(v); i8 = int8(i32); w = big(i8)
+ case ti32*100 + tu8:
+ i32 = int32(v); u8 = uint8(i32); w = big(u8)
+ case ti32*100 + ti16:
+ i32 = int32(v); i16 = int16(i32); w = big(i16)
+ case ti32*100 + tu16:
+ i32 = int32(v); u16 = uint16(i32); w = big(u16)
+ case ti32*100 + ti32:
+ i32 = int32(v); i32 = int32(i32); w = big(i32)
+ case ti32*100 + tu32:
+ i32 = int32(v); u32 = uint32(i32); w = big(u32)
+ case ti32*100 + ti64:
+ i32 = int32(v); i64 = int64(i32); w = big(i64)
+ case ti32*100 + tu64:
+ i32 = int32(v); u64 = uint64(i32); w = big(u64)
+ case ti32*100 + tf32:
+ i32 = int32(v); f32 = float32(i32); w = big(f32)
+ case ti32*100 + tf64:
+ i32 = int32(v); f64 = float64(i32); w = big(f64)
+
+ case tu32*100 + ti8:
+ u32 = uint32(v); i8 = int8(u32); w = big(i8)
+ case tu32*100 + tu8:
+ u32 = uint32(v); u8 = uint8(u32); w = big(u8)
+ case tu32*100 + ti16:
+ u32 = uint32(v); i16 = int16(u32); w = big(i16)
+ case tu32*100 + tu16:
+ u32 = uint32(v); u16 = uint16(u32); w = big(u16)
+ case tu32*100 + ti32:
+ u32 = uint32(v); i32 = int32(u32); w = big(i32)
+ case tu32*100 + tu32:
+ u32 = uint32(v); u32 = uint32(u32); w = big(u32)
+ case tu32*100 + ti64:
+ u32 = uint32(v); i64 = int64(u32); w = big(i64)
+ case tu32*100 + tu64:
+ u32 = uint32(v); u64 = uint64(u32); w = big(u64)
+ case tu32*100 + tf32:
+ u32 = uint32(v); f32 = float32(u32); w = big(f32)
+ case tu32*100 + tf64:
+ u32 = uint32(v); f64 = float64(u32); w = big(f64)
+
+ case ti64*100 + ti8:
+ i64 = int64(v); i8 = int8(i64); w = big(i8)
+ case ti64*100 + tu8:
+ i64 = int64(v); u8 = uint8(i64); w = big(u8)
+ case ti64*100 + ti16:
+ i64 = int64(v); i16 = int16(i64); w = big(i16)
+ case ti64*100 + tu16:
+ i64 = int64(v); u16 = uint16(i64); w = big(u16)
+ case ti64*100 + ti32:
+ i64 = int64(v); i32 = int32(i64); w = big(i32)
+ case ti64*100 + tu32:
+ i64 = int64(v); u32 = uint32(i64); w = big(u32)
+ case ti64*100 + ti64:
+ i64 = int64(v); i64 = int64(i64); w = big(i64)
+ case ti64*100 + tu64:
+ i64 = int64(v); u64 = uint64(i64); w = big(u64)
+ case ti64*100 + tf32:
+ i64 = int64(v); f32 = float32(i64); w = big(f32)
+ case ti64*100 + tf64:
+ i64 = int64(v); f64 = float64(i64); w = big(f64)
+
+ case tu64*100 + ti8:
+ u64 = uint64(v); i8 = int8(u64); w = big(i8)
+ case tu64*100 + tu8:
+ u64 = uint64(v); u8 = uint8(u64); w = big(u8)
+ case tu64*100 + ti16:
+ u64 = uint64(v); i16 = int16(u64); w = big(i16)
+ case tu64*100 + tu16:
+ u64 = uint64(v); u16 = uint16(u64); w = big(u16)
+ case tu64*100 + ti32:
+ u64 = uint64(v); i32 = int32(u64); w = big(i32)
+ case tu64*100 + tu32:
+ u64 = uint64(v); u32 = uint32(u64); w = big(u32)
+ case tu64*100 + ti64:
+ u64 = uint64(v); i64 = int64(u64); w = big(i64)
+ case tu64*100 + tu64:
+ u64 = uint64(v); u64 = uint64(u64); w = big(u64)
+ case tu64*100 + tf32:
+ u64 = uint64(v); f32 = float32(u64); w = big(f32)
+ case tu64*100 + tf64:
+ u64 = uint64(v); f64 = float64(u64); w = big(f64)
+
+ case tf32*100 + ti8:
+ f32 = float32(v); i8 = int8(f32); w = big(i8)
+ case tf32*100 + tu8:
+ f32 = float32(v); u8 = uint8(f32); w = big(u8)
+ case tf32*100 + ti16:
+ f32 = float32(v); i16 = int16(f32); w = big(i16)
+ case tf32*100 + tu16:
+ f32 = float32(v); u16 = uint16(f32); w = big(u16)
+ case tf32*100 + ti32:
+ f32 = float32(v); i32 = int32(f32); w = big(i32)
+ case tf32*100 + tu32:
+ f32 = float32(v); u32 = uint32(f32); w = big(u32)
+ case tf32*100 + ti64:
+ f32 = float32(v); i64 = int64(f32); w = big(i64)
+ case tf32*100 + tu64:
+ f32 = float32(v); u64 = uint64(f32); w = big(u64)
+ case tf32*100 + tf32:
+ f32 = float32(v); f32 = float32(f32); w = big(f32)
+ case tf32*100 + tf64:
+ f32 = float32(v); f64 = float64(f32); w = big(f64)
+
+ case tf64*100 + ti8:
+ f64 = float64(v); i8 = int8(f64); w = big(i8)
+ case tf64*100 + tu8:
+ f64 = float64(v); u8 = uint8(f64); w = big(u8)
+ case tf64*100 + ti16:
+ f64 = float64(v); i16 = int16(f64); w = big(i16)
+ case tf64*100 + tu16:
+ f64 = float64(v); u16 = uint16(f64); w = big(u16)
+ case tf64*100 + ti32:
+ f64 = float64(v); i32 = int32(f64); w = big(i32)
+ case tf64*100 + tu32:
+ f64 = float64(v); u32 = uint32(f64); w = big(u32)
+ case tf64*100 + ti64:
+ f64 = float64(v); i64 = int64(f64); w = big(i64)
+ case tf64*100 + tu64:
+ f64 = float64(v); u64 = uint64(f64); w = big(u64)
+ case tf64*100 + tf32:
+ f64 = float64(v); f32 = float32(f64); w = big(f32)
+ case tf64*100 + tf64:
+ f64 = float64(v); f64 = float64(f64); w = big(f64)
+ }
+ if v != w { println(i, v, w, f, t) }
+ }
+}
func main() {
- r := 5 + 0i
+ var r complex64 = 5 + 0i
if r != R {
println("opcode 1", r, R)
panic("fail")
}
- i := 6i
+ var i complex64 = 6i
if i != I {
println("opcode 2", i, I)
panic("fail")
--- /dev/null
+// 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.
+
+// Pass 1 label errors.
+
+package main
+
+var x int
+
+func f() {
+L1: // ERROR "label .*L1.* defined and not used"
+ for {
+ }
+L2: // ERROR "label .*L2.* defined and not used"
+ select {
+ }
+L3: // ERROR "label .*L3.* defined and not used"
+ switch {
+ }
+L4: // ERROR "label .*L4.* defined and not used"
+ if true {
+ }
+L5: // ERROR "label .*L5.* defined and not used"
+ f()
+L6: // GCCGO_ERROR "previous"
+ f()
+L6: // ERROR "label .*L6.* already defined"
+ f()
+ if x == 20 {
+ goto L6
+ }
+
+L7:
+ for {
+ break L7
+ }
+
+L8:
+ for {
+ if x == 21 {
+ continue L8
+ }
+ }
+
+L9:
+ switch {
+ case true:
+ break L9
+ defalt: // ERROR "label .*defalt.* defined and not used"
+ }
+
+L10:
+ select {
+ default:
+ break L10
+ }
+}
--- /dev/null
+// 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.
+
+// Pass 2 label errors.
+
+package main
+
+var x int
+
+func f() {
+L1:
+ for {
+ if x == 0 {
+ break L1
+ }
+ if x == 1 {
+ continue L1
+ }
+ goto L1
+ }
+
+L2:
+ select {
+ default:
+ if x == 0 {
+ break L2
+ }
+ if x == 1 {
+ continue L2 // ERROR "invalid continue label .*L2"
+ }
+ goto L2
+ }
+
+L3:
+ switch {
+ case x > 10:
+ if x == 11 {
+ break L3
+ }
+ if x == 12 {
+ continue L3 // ERROR "invalid continue label .*L3"
+ }
+ goto L3
+ }
+
+L4:
+ if true {
+ if x == 13 {
+ break L4 // ERROR "invalid break label .*L4"
+ }
+ if x == 14 {
+ continue L4 // ERROR "invalid continue label .*L4"
+ }
+ if x == 15 {
+ goto L4
+ }
+ }
+
+L5:
+ f()
+ if x == 16 {
+ break L5 // ERROR "invalid break label .*L5"
+ }
+ if x == 17 {
+ continue L5 // ERROR "invalid continue label .*L5"
+ }
+ if x == 18 {
+ goto L5
+ }
+
+ for {
+ if x == 19 {
+ break L1 // ERROR "invalid break label .*L1"
+ }
+ if x == 20 {
+ continue L1 // ERROR "invalid continue label .*L1"
+ }
+ if x == 21 {
+ goto L1
+ }
+ }
+}
func (s *S1) val() int { return 2 }
func (i I) val() int { return 3 }
func (i *I1) val() int { return 4 }
-//func (t T) val() int { return 7 }
+func (t T) val() int { return 7 }
func (t *T1) val() int { return 8 }
type Val interface {
var i I
var pi *I1
var pt *T1
+ var t T
+ var v Val
if s.val() != 1 {
println("s.val:", s.val())
println("(*I1).val(pi):", (*I1).val(pi))
panic("fail")
}
- // if t.val() != 7 { prinln("t.val:", t.val()); panic("fail") }
+ if t.val() != 7 {
+ println("t.val:", t.val())
+ panic("fail")
+ }
if pt.val() != 8 {
println("pt.val:", pt.val())
panic("fail")
println("pi.val:", val(pi))
panic("fail")
}
- // if val(t) != 7 { println("t.val:", val(t)); panic("fail") }
+ if val(t) != 7 {
+ println("t.val:", val(t))
+ panic("fail")
+ }
if val(pt) != 8 {
println("pt.val:", val(pt))
panic("fail")
}
- // if Val.val(i) != 3 { println("Val.val(i):", Val.val(i)); panic("fail") }
+ if Val.val(i) != 3 {
+ println("Val.val(i):", Val.val(i))
+ panic("fail")
+ }
+ v = i
+ if Val.val(v) != 3 {
+ println("Val.val(v):", Val.val(v))
+ panic("fail")
+ }
}
package main
-type T struct {a int}
+type T struct {
+ a int
+}
type P *T
type P1 *T
-func (p P) val() int { return 1 } // ERROR "receiver"
-func (p *P1) val() int { return 1 } // ERROR "receiver"
+func (p P) val() int { return 1 } // ERROR "receiver"
+func (p *P1) val() int { return 1 } // ERROR "receiver"
+
+type Val interface {
+ val() int
+}
+
+var _ = (*Val).val // ERROR "method"
+
+var v Val
+var pv = &v
+
+var _ = pv.val() // ERROR "method"
-// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
// $G $D/$F.go && $L $F.$A &&
// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
// $G $D/$F.go && $L $F.$A &&
// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
// $G $D/$F.go && $L $F.$A &&
// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
// $G $D/$F.go && $L $F.$A &&
// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
// $G $D/$F.go && $L $F.$A &&
// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
// $G $D/$F.go && $L $F.$A &&
// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
// $G $D/$F.go && $L $F.$A &&
// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
// $G $D/$F.go && $L $F.$A &&
// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
// $G $D/$F.go && $L $F.$A &&
// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-// [ $GOOS != nacl ] || exit 0 # do not bother on NaCl
// $G $D/$F.go && $L $F.$A &&
// ((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-// [ $GOOS != nacl ] || exit 0 # NaCl runner elides NUL in output
// [ "$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
-// [ $GOOS != nacl ] || exit 0 # NaCl cannot recover from signals
// $G $D/$F.go && $L $F.$A && ./$A.out
// Copyright 2010 The Go Authors. All rights reserved.
import (
"runtime"
"strings"
- "syscall"
)
var didbug bool
return
}
}()
-
+
f()
}
var q *[10000]int
var i int
- // not catching divide by zero on the arm. is that even possible?
- if syscall.ARCH != "arm" {
- check("int-div-zero", func() { println(1/x) }, "integer divide by zero")
- check("int64-div-zero", func() { println(1/x64) }, "integer divide by zero")
- }
+ check("int-div-zero", func() { println(1 / x) }, "integer divide by zero")
+ check("int64-div-zero", func() { println(1 / x64) }, "integer divide by zero")
check("nil-deref", func() { println(p[0]) }, "nil pointer dereference")
check("nil-deref-1", func() { println(p[1]) }, "nil pointer dereference")
var sl []int
check("array-bounds", func() { println(p[i]) }, "index out of range")
check("slice-bounds", func() { println(sl[i]) }, "index out of range")
-
+
var inter interface{}
inter = 1
check("type-concrete", func() { println(inter.(string)) }, "int, not string")
check("type-interface", func() { println(inter.(m)) }, "missing method m")
}
-type m interface{ m() }
+type m interface {
+ m()
+}
;;
Xarm)
export A=5
- export E=${GORUN:-qemu-arm -cpu cortex-a8}
+ export E="$GORUN"
;;
*)
echo 1>&2 run: unsupported '$GOARCH'
true >pass.out >times.out
+exclude=false # exclude nothing
+golden=golden.out
+
+filterout() {
+ grep '^'"$2"'$' $1 >/dev/null
+}
+
for dir in . ken chan interface nilptr syntax fixedbugs bugs
do
echo
echo '==' $dir'/'
for i in $(ls $dir/*.go 2>/dev/null)
- do
+ do (
+ if $exclude $i; then
+ exit 0 # continues for loop
+ fi
export F=$(basename $i .go)
export D=$dir
- sed '/^\/\//!q' $i | sed 's@//@@; $d' |sed 's|./\$A.out|$E &|' >$RUNFILE
+ sed '/^\/\//!q' $i | sed 's@//@@; $d' |sed 's|./\$A.out|$E &|g' >$RUNFILE
if ! { time -p bash -c "bash $RUNFILE >$TMP1FILE 2>&1" ; } 2>$TMP2FILE
then
echo
echo $i >>pass.out
fi
echo $(awk 'NR==1{print $2}' $TMP2FILE) $D/$F >>times.out
- done
+ ) done
done | # clean up some stack noise
egrep -v '^(r[0-9a-z]+|[cfg]s) +0x' |
sed '/tmp.*Bus error/s/.*Bus/Bus/; /tmp.*Trace.BPT/s/.*Trace/Trace/
/^Trace\/BPT trap/d
/RUNFILE/ s/line 1: *[0-9]*/line 1: PID/
/^\$RUNFILE: line 1: PID Trace\/breakpoint trap/d
+ /Fault in NaCl untrusted code/d
/Segmentation fault/d
/^qemu: uncaught target signal 11 (Segmentation fault) - exiting/d' > run.out
-rm -f $RUNFILE $TMP1FILE $TMP2FILE *.$A *.a $A.out
+rm -f $RUNFILE $TMP1FILE $TMP2FILE *.$A *.a $A.out
diffmsg=""
-if ! diff golden.out run.out
+if ! diff $golden run.out
then
diffmsg="; test output differs"
failed=1
+++ /dev/null
-#!/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.
-
-export E=""
-case X"$GOARCH" in
-Xamd64)
- export A=6
- ;;
-X386)
- export A=8
- ;;
-Xarm)
- export A=5
- export E="${GORUN:-qemu-arm -cpu cortex-a8}"
- ;;
-*)
- echo 1>&2 run: unsupported '$GOARCH'
- exit 1
-esac
-
-export G=${A}g
-export L=${A}l
-export GOTRACEBACK=0
-
-PATH=/bin:/usr/bin:/usr/local/bin:${GOBIN:-$GOROOT/bin}:`pwd`
-
-RUNFILE=/tmp/gorun-$$-$USER
-TMP1FILE=/tmp/gotest1-$$-$USER
-TMP2FILE=/tmp/gotest2-$$-$USER
-FAILEDFILE=/tmp/gotest3-$$-$USER
-
-# don't run the machine out of memory: limit individual processes to 4GB.
-# on thresher, 3GB suffices to run the tests; with 2GB, peano fails.
-ulimit -v 4000000
-
-# no core files please
-ulimit -c 0
-
-true >times.out
-
-# TODO(kaib): figure out why the GC makes things so utterly slow.
-export GOGC=off
-export GOTRACEBACK=0
-
-for i in $(cat arm-pass.txt | sed 's/#.*//')
-do
- export F=$(basename $i .go)
- dir=$(dirname $i)
- export D=$dir
- sed '/^\/\//!q' $i | sed 's@//@@; $d' |sed 's|./\$A.out|$E &|' >$RUNFILE
- if ! { time -p bash -c "bash $RUNFILE >$TMP1FILE 2>&1" ; } 2>$TMP2FILE
- then
- echo
- echo "===========" $i
- cat $TMP1FILE
- echo >&2 fail: $i
- touch $FAILEDFILE
- elif test -s $TMP1FILE
- then
- echo
- echo "===========" $i
- cat $TMP1FILE
- elif [ $dir = "bugs" ]
- then
- echo $i succeeded with no output.
- fi
- echo $(awk 'NR==1{print $2}' $TMP2FILE) $D/$F >>times.out
-done | # clean up some stack noise
- egrep -v '^(r[0-9a-z]+|[cfg]s) +0x' |
- sed '/tmp.*Bus error/s/.*Bus/Bus/; /tmp.*Trace.BPT/s/.*Trace/Trace/
- s!'$RUNFILE'!$RUNFILE!g
- s/ PC=0x[0-9a-f]*/ PC=xxx/
- s/^pc: 0x[0-9a-f]*/pc: xxx/
- /^Trace\/breakpoint trap/d
- /^Trace\/BPT trap/d
- s!'$GOROOT'!$GOROOT!g
- /Segmentation fault/d
- /RUNFILE/ s/line 1: *[0-9]*/line 1: PID/
- /^\$RUNFILE: line 1: PID Trace\/breakpoint trap/d
- /^qemu: uncaught target signal 11 (Segmentation fault) - exiting/d' > run.out
-
-failed=0
-rm -f $RUNFILE $TMP1FILE $TMP2FILE *.$A $A.out
-diffmsg=""
-if ! diff -b golden-arm.out run.out
-then
- diffmsg="; test output differs"
- failed=1
-fi
-
-notinbugs=$(sed '/== bugs/q' run.out | grep -c '^BUG')
-inbugs=$(sed '1,/== bugs/d' run.out | grep -c '^BUG')
-
-echo 2>&1 $inbugs known bugs';' $notinbugs unexpected bugs$diffmsg
-
-if [ "$failed" != "0" ]; then
- echo FAILED
-fi
-
-exit $failed
-// if [ $GOOS == nacl ]; then echo survived SIGCHLD; exit 0; fi # NaCl has no signals.
// $G $D/$F.go && $L $F.$A && ./$A.out
// Copyright 2009 The Go Authors. All rights reserved.
}
}
+func f0() {
+ // likely to make a new stack for f0,
+ // because the call to f1 puts 3000 bytes
+ // in our frame.
+ f1()
+}
+
+func f1() [3000]byte {
+ // likely to make a new stack for f1,
+ // because 3000 bytes were used by f0
+ // and we need 3000 more for the call
+ // to f2. if the call to morestack in f1
+ // does not pass the frame size, the new
+ // stack (default size 5k) will not be big
+ // enough for the frame, and the morestack
+ // check in f2 will die, if we get that far
+ // without faulting.
+ f2()
+ return [3000]byte{}
+}
+
+func f2() [3000]byte {
+ // just take up space
+ return [3000]byte{}
+}
+
var c = make(chan int)
var t T
var b = []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
panic("bad []byte -> string")
}
go g(c, t)
+ f0()
s := <-c
if s != len(t) {
println("bad go", s)
--- /dev/null
+// 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 xyz struct {
+ ch chan
+} // ERROR "unexpected .*}.* in channel type"
+
+func Foo(y chan) { // ERROR "unexpected .*\).* in channel type"
+}
+
+func Bar(x chan, y int) { // ERROR "unexpected comma in channel type"
+}
--- /dev/null
+// 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 c chan int
+var v int
+
+func main() {
+ if c <- v { // ERROR "send statement.*value.*select"
+ }
+}
+
+var _ = c <- v // ERROR "send statement.*value.*select"
--- /dev/null
+// 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
+
+func x() {
+}
+
+func main() {
+ if { // ERROR "missing condition"
+ }
+
+ if x(); { // ERROR "missing condition"
+ }
+}
--- /dev/null
+// 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.
+
+package main
+
+func main() {
+ switch main() := interface{}(nil).(type) { // ERROR "invalid variable name"
+ default:
+ }
+}
projects / gcc.git / commitdiff