Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2024-02-02 18:09
📄 array.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test arrays and slices. package main func setpd(a []int) { // print("setpd a=", a, " len=", len(a), " cap=", cap(a), "\n"); for i := 0; i < len(a); i++ { a[i] = i } } func sumpd(a []int) int { // print("sumpd a=", a, " len=", len(a), " cap=", cap(a), "\n"); t := 0 for i := 0; i < len(a); i++ { t += a[i] } // print("sumpd t=", t, "\n"); return t } func setpf(a [20]int) { // print("setpf a=", a, " len=", len(a), " cap=", cap(a), "\n"); for i := 0; i < len(a); i++ { a[i] = i } } func sumpf(a [20]int) int { // print("sumpf a=", a, " len=", len(a), " cap=", cap(a), "\n"); t := 0 for i := 0; i < len(a); i++ { t += a[i] } // print("sumpf t=", t, "\n"); return t } func res(t int, lb, hb int) { sb := (hb - lb) * (hb + lb - 1) / 2 if t != sb { print("lb=", lb, "; hb=", hb, "; t=", t, "; sb=", sb, "\n") panic("res") } } // call ptr dynamic with ptr dynamic func testpdpd() { a := make([]int, 10, 100) if len(a) != 10 && cap(a) != 100 { print("len and cap from new: ", len(a), " ", cap(a), "\n") panic("fail") } a = a[0:100] setpd(a) a = a[0:10] res(sumpd(a), 0, 10) a = a[5:25] res(sumpd(a), 5, 25) a = a[30:95] res(sumpd(a), 35, 100) } // call ptr fixed with ptr fixed func testpfpf() { var a [20]int setpf(&a) res(sumpf(&a), 0, 20) } // call ptr dynamic with ptr fixed from new func testpdpf1() { a := new([40]int) setpd(a[0:]) res(sumpd(a[0:]), 0, 40) b := (*a)[5:30] res(sumpd(b), 5, 30) } // call ptr dynamic with ptr fixed from var func testpdpf2() { var a [80]int setpd(a[0:]) res(sumpd(a[0:]), 0, 80) } // generate bounds error with ptr dynamic func testpdfault() { a := make([]int, 100) print("good\n") for i := 0; i < 100; i++ { a[i] = 0 } print("should fault\n") a[100] = 0 print("bad\n") } // generate bounds error with ptr fixed func testfdfault() { var a [80]int print("good\n") for i := 0; i < 80; i++ { a[i] = 0 } print("should fault\n") x := 80 a[x] = 0 print("bad\n") } func main() { testpdpd() testpfpf() testpdpf1() testpdpf2() // print("testpdfault\n"); testpdfault(); // print("testfdfault\n"); testfdfault(); }	2.27 KB	2024-02-02 18:09
📄 chan.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test communication operations including select. package main import "os" import "runtime" import "sync" var randx int func nrand(n int) int { randx += 10007 if randx >= 1000000 { randx -= 1000000 } return randx % n } type Chan struct { sc, rc chan int // send and recv chan sv, rv int // send and recv seq } var ( nproc int nprocLock sync.Mutex cval int end int = 10000 totr, tots int totLock sync.Mutex nc Chan ) func init() { nc = new(Chan) } func changeNproc(adjust int) int { nprocLock.Lock() nproc += adjust ret := nproc nprocLock.Unlock() return ret } func mkchan(c, n int) []Chan { ca := make([]Chan, n) for i := 0; i < n; i++ { cval = cval + 100 ch := new(Chan) ch.sc = make(chan int, c) ch.rc = ch.sc ch.sv = cval ch.rv = cval ca[i] = ch } return ca } func expect(v, v0 int) (newv int) { if v == v0 { if v%100 == 75 { return end } return v + 1 } print("got ", v, " expected ", v0+1, "\n") panic("fail") } func (c Chan) send() bool { // print("send ", c.sv, "\n"); totLock.Lock() tots++ totLock.Unlock() c.sv = expect(c.sv, c.sv) if c.sv == end { c.sc = nil return true } return false } func send(c Chan) { for { for r := nrand(10); r >= 0; r-- { runtime.Gosched() } c.sc <- c.sv if c.send() { break } } changeNproc(-1) } func (c Chan) recv(v int) bool { // print("recv ", v, "\n"); totLock.Lock() totr++ totLock.Unlock() c.rv = expect(c.rv, v) if c.rv == end { c.rc = nil return true } return false } func recv(c Chan) { var v int for { for r := nrand(10); r >= 0; r-- { runtime.Gosched() } v = <-c.rc if c.recv(v) { break } } changeNproc(-1) } func sel(r0, r1, r2, r3, s0, s1, s2, s3 Chan) { var v int a := 0 // local chans running if r0.rc != nil { a++ } if r1.rc != nil { a++ } if r2.rc != nil { a++ } if r3.rc != nil { a++ } if s0.sc != nil { a++ } if s1.sc != nil { a++ } if s2.sc != nil { a++ } if s3.sc != nil { a++ } for { for r := nrand(5); r >= 0; r-- { runtime.Gosched() } select { case v = <-r0.rc: if r0.recv(v) { a-- } case v = <-r1.rc: if r1.recv(v) { a-- } case v = <-r2.rc: if r2.recv(v) { a-- } case v = <-r3.rc: if r3.recv(v) { a-- } case s0.sc <- s0.sv: if s0.send() { a-- } case s1.sc <- s1.sv: if s1.send() { a-- } case s2.sc <- s2.sv: if s2.send() { a-- } case s3.sc <- s3.sv: if s3.send() { a-- } } if a == 0 { break } } changeNproc(-1) } // direct send to direct recv func test1(c Chan) { changeNproc(2) go send(c) go recv(c) } // direct send to select recv func test2(c int) { ca := mkchan(c, 4) changeNproc(4) go send(ca[0]) go send(ca[1]) go send(ca[2]) go send(ca[3]) changeNproc(1) go sel(ca[0], ca[1], ca[2], ca[3], nc, nc, nc, nc) } // select send to direct recv func test3(c int) { ca := mkchan(c, 4) changeNproc(4) go recv(ca[0]) go recv(ca[1]) go recv(ca[2]) go recv(ca[3]) changeNproc(1) go sel(nc, nc, nc, nc, ca[0], ca[1], ca[2], ca[3]) } // select send to select recv func test4(c int) { ca := mkchan(c, 4) changeNproc(2) go sel(nc, nc, nc, nc, ca[0], ca[1], ca[2], ca[3]) go sel(ca[0], ca[1], ca[2], ca[3], nc, nc, nc, nc) } func test5(c int) { ca := mkchan(c, 8) changeNproc(2) go sel(ca[4], ca[5], ca[6], ca[7], ca[0], ca[1], ca[2], ca[3]) go sel(ca[0], ca[1], ca[2], ca[3], ca[4], ca[5], ca[6], ca[7]) } func test6(c int) { ca := mkchan(c, 12) changeNproc(4) go send(ca[4]) go send(ca[5]) go send(ca[6]) go send(ca[7]) changeNproc(4) go recv(ca[8]) go recv(ca[9]) go recv(ca[10]) go recv(ca[11]) changeNproc(2) go sel(ca[4], ca[5], ca[6], ca[7], ca[0], ca[1], ca[2], ca[3]) go sel(ca[0], ca[1], ca[2], ca[3], ca[8], ca[9], ca[10], ca[11]) } // wait for outstanding tests to finish func wait() { runtime.Gosched() for changeNproc(0) != 0 { runtime.Gosched() } } // run all tests with specified buffer size func tests(c int) { ca := mkchan(c, 4) test1(ca[0]) test1(ca[1]) test1(ca[2]) test1(ca[3]) wait() test2(c) wait() test3(c) wait() test4(c) wait() test5(c) wait() test6(c) wait() } // run all test with 4 buffser sizes func main() { tests(0) tests(1) tests(10) tests(100) t := 4 // buffer sizes (44 + // tests 1,2,3,4 channels 8 + // test 5 channels 12) // test 6 channels 76 // sends/recvs on a channel if tots != t \|\| totr != t { print("tots=", tots, " totr=", totr, " sb=", t, "\n") os.Exit(1) } os.Exit(0) }	4.67 KB	2024-02-02 18:09
📄 chan1.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test communication with multiple simultaneous goroutines. package main import "runtime" const N = 1000 // sent messages const M = 10 // receiving goroutines const W = 2 // channel buffering var h [N]int // marking of send/recv func r(c chan int, m int) { for { select { case r := <-c: if h[r] != 1 { println("r", "m=", m, "r=", r, "h=", h[r]) panic("fail") } h[r] = 2 } } } func s(c chan int) { for n := 0; n < N; n++ { r := n if h[r] != 0 { println("s") panic("fail") } h[r] = 1 c <- r } } func main() { c := make(chan int, W) for m := 0; m < M; m++ { go r(c, m) runtime.Gosched() } runtime.Gosched() runtime.Gosched() s(c) }	879 B	2024-02-02 18:09
📄 complit.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test composite literals. package main type M map[int]int type S struct{ a,b,c int }; type SS struct{ aa,bb,cc S }; type SA struct{ a,b,c [3]int }; type SC struct{ a,b,c []int }; type SM struct{ a,b,c M }; func main() { test("s.a", s.a); test("s.b", s.b); test("s.c", s.c); test("ss.aa.a", ss.aa.a); test("ss.aa.b", ss.aa.b); test("ss.aa.c", ss.aa.c); test("ss.bb.a", ss.bb.a); test("ss.bb.b", ss.bb.b); test("ss.bb.c", ss.bb.c); test("ss.cc.a", ss.cc.a); test("ss.cc.b", ss.cc.b); test("ss.cc.c", ss.cc.c); for i:=0; i<3; i++ { test("a[i]", a[i]); test("c[i]", c[i]); test("m[i]", m[i]); test("as[i].a", as[i].a); test("as[i].b", as[i].b); test("as[i].c", as[i].c); test("cs[i].a", cs[i].a); test("cs[i].b", cs[i].b); test("cs[i].c", cs[i].c); test("ms[i].a", ms[i].a); test("ms[i].b", ms[i].b); test("ms[i].c", ms[i].c); test("sa.a[i]", sa.a[i]); test("sa.b[i]", sa.b[i]); test("sa.c[i]", sa.c[i]); test("sc.a[i]", sc.a[i]); test("sc.b[i]", sc.b[i]); test("sc.c[i]", sc.c[i]); test("sm.a[i]", sm.a[i]); test("sm.b[i]", sm.b[i]); test("sm.c[i]", sm.c[i]); for j:=0; j<3; j++ { test("aa[i][j]", aa[i][j]); test("ac[i][j]", ac[i][j]); test("am[i][j]", am[i][j]); test("ca[i][j]", ca[i][j]); test("cc[i][j]", cc[i][j]); test("cm[i][j]", cm[i][j]); test("ma[i][j]", ma[i][j]); test("mc[i][j]", mc[i][j]); test("mm[i][j]", mm[i][j]); } } } var ref = 0; func test(xs string, x int) { if ref >= len(answers) { println(xs, x); return; } if x != answers[ref] { println(xs, "is", x, "should be", answers[ref]) } ref++; } var a = [3]int{1001, 1002, 1003} var s = S{1101, 1102, 1103} var c = []int{1201, 1202, 1203} var m = M{0:1301, 1:1302, 2:1303} var aa = [3][3]int{[3]int{2001,2002,2003}, [3]int{2004,2005,2006}, [3]int{2007,2008,2009}} var as = [3]S{S{2101,2102,2103},S{2104,2105,2106},S{2107,2108,2109}} var ac = [3][]int{[]int{2201,2202,2203}, []int{2204,2205,2206}, []int{2207,2208,2209}} var am = [3]M{M{0:2301,1:2302,2:2303}, M{0:2304,1:2305,2:2306}, M{0:2307,1:2308,2:2309}} var sa = SA{[3]int{3001,3002,3003},[3]int{3004,3005,3006},[3]int{3007,3008,3009}} var ss = SS{S{3101,3102,3103},S{3104,3105,3106},S{3107,3108,3109}} var sc = SC{[]int{3201,3202,3203},[]int{3204,3205,3206},[]int{3207,3208,3209}} var sm = SM{M{0:3301,1:3302,2:3303}, M{0:3304,1:3305,2:3306}, M{0:3307,1:3308,2:3309}} var ca = [][3]int{[3]int{4001,4002,4003}, [3]int{4004,4005,4006}, [3]int{4007,4008,4009}} var cs = []S{S{4101,4102,4103},S{4104,4105,4106},S{4107,4108,4109}} var cc = [][]int{[]int{4201,4202,4203}, []int{4204,4205,4206}, []int{4207,4208,4209}} var cm = []M{M{0:4301,1:4302,2:4303}, M{0:4304,1:4305,2:4306}, M{0:4307,1:4308,2:4309}} var ma = map[int][3]int{0:[3]int{5001,5002,5003}, 1:[3]int{5004,5005,5006}, 2:[3]int{5007,5008,5009}} var ms = map[int]S{0:S{5101,5102,5103},1:S{5104,5105,5106},2:S{5107,5108,5109}} var mc = map[int][]int{0:[]int{5201,5202,5203}, 1:[]int{5204,5205,5206}, 2:[]int{5207,5208,5209}} var mm = map[int]M{0:M{0:5301,1:5302,2:5303}, 1:M{0:5304,1:5305,2:5306}, 2:M{0:5307,1:5308,2:5309}} var answers = [...]int { // s 1101, 1102, 1103, // ss 3101, 3102, 3103, 3104, 3105, 3106, 3107, 3108, 3109, // [0] 1001, 1201, 1301, 2101, 2102, 2103, 4101, 4102, 4103, 5101, 5102, 5103, 3001, 3004, 3007, 3201, 3204, 3207, 3301, 3304, 3307, // [0][j] 2001, 2201, 2301, 4001, 4201, 4301, 5001, 5201, 5301, 2002, 2202, 2302, 4002, 4202, 4302, 5002, 5202, 5302, 2003, 2203, 2303, 4003, 4203, 4303, 5003, 5203, 5303, // [1] 1002, 1202, 1302, 2104, 2105, 2106, 4104, 4105, 4106, 5104, 5105, 5106, 3002, 3005, 3008, 3202, 3205, 3208, 3302, 3305, 3308, // [1][j] 2004, 2204, 2304, 4004, 4204, 4304, 5004, 5204, 5304, 2005, 2205, 2305, 4005, 4205, 4305, 5005, 5205, 5305, 2006, 2206, 2306, 4006, 4206, 4306, 5006, 5206, 5306, // [2] 1003, 1203, 1303, 2107, 2108, 2109, 4107, 4108, 4109, 5107, 5108, 5109, 3003, 3006, 3009, 3203, 3206, 3209, 3303, 3306, 3309, // [2][j] 2007, 2207, 2307, 4007, 4207, 4307, 5007, 5207, 5307, 2008, 2208, 2308, 4008, 4208, 4308, 5008, 5208, 5308, 2009, 2209, 2309, 4009, 4209, 4309, 5009, 5209, 5309, }	4.27 KB	2024-02-02 18:09
📄 convert.go // run // Copyright 2010 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test, near-exhaustive, of converting numbers between types. // No complex numbers though. 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 f100 + t { default: println("missing case", i, v, f, t) w = v case ti8100 + ti8: i8 = int8(v); i8 = int8(i8); w = big(i8) case ti8100 + tu8: i8 = int8(v); u8 = uint8(i8); w = big(u8) case ti8100 + ti16: i8 = int8(v); i16 = int16(i8); w = big(i16) case ti8100 + tu16: i8 = int8(v); u16 = uint16(i8); w = big(u16) case ti8100 + ti32: i8 = int8(v); i32 = int32(i8); w = big(i32) case ti8100 + tu32: i8 = int8(v); u32 = uint32(i8); w = big(u32) case ti8100 + ti64: i8 = int8(v); i64 = int64(i8); w = big(i64) case ti8100 + tu64: i8 = int8(v); u64 = uint64(i8); w = big(u64) case ti8100 + tf32: i8 = int8(v); f32 = float32(i8); w = big(f32) case ti8100 + tf64: i8 = int8(v); f64 = float64(i8); w = big(f64) case tu8100 + ti8: u8 = uint8(v); i8 = int8(u8); w = big(i8) case tu8100 + tu8: u8 = uint8(v); u8 = uint8(u8); w = big(u8) case tu8100 + ti16: u8 = uint8(v); i16 = int16(u8); w = big(i16) case tu8100 + tu16: u8 = uint8(v); u16 = uint16(u8); w = big(u16) case tu8100 + ti32: u8 = uint8(v); i32 = int32(u8); w = big(i32) case tu8100 + tu32: u8 = uint8(v); u32 = uint32(u8); w = big(u32) case tu8100 + ti64: u8 = uint8(v); i64 = int64(u8); w = big(i64) case tu8100 + tu64: u8 = uint8(v); u64 = uint64(u8); w = big(u64) case tu8100 + tf32: u8 = uint8(v); f32 = float32(u8); w = big(f32) case tu8100 + tf64: u8 = uint8(v); f64 = float64(u8); w = big(f64) case ti16100 + ti8: i16 = int16(v); i8 = int8(i16); w = big(i8) case ti16100 + tu8: i16 = int16(v); u8 = uint8(i16); w = big(u8) case ti16100 + ti16: i16 = int16(v); i16 = int16(i16); w = big(i16) case ti16100 + tu16: i16 = int16(v); u16 = uint16(i16); w = big(u16) case ti16100 + ti32: i16 = int16(v); i32 = int32(i16); w = big(i32) case ti16100 + tu32: i16 = int16(v); u32 = uint32(i16); w = big(u32) case ti16100 + ti64: i16 = int16(v); i64 = int64(i16); w = big(i64) case ti16100 + tu64: i16 = int16(v); u64 = uint64(i16); w = big(u64) case ti16100 + tf32: i16 = int16(v); f32 = float32(i16); w = big(f32) case ti16100 + tf64: i16 = int16(v); f64 = float64(i16); w = big(f64) case tu16100 + ti8: u16 = uint16(v); i8 = int8(u16); w = big(i8) case tu16100 + tu8: u16 = uint16(v); u8 = uint8(u16); w = big(u8) case tu16100 + ti16: u16 = uint16(v); i16 = int16(u16); w = big(i16) case tu16100 + tu16: u16 = uint16(v); u16 = uint16(u16); w = big(u16) case tu16100 + ti32: u16 = uint16(v); i32 = int32(u16); w = big(i32) case tu16100 + tu32: u16 = uint16(v); u32 = uint32(u16); w = big(u32) case tu16100 + ti64: u16 = uint16(v); i64 = int64(u16); w = big(i64) case tu16100 + tu64: u16 = uint16(v); u64 = uint64(u16); w = big(u64) case tu16100 + tf32: u16 = uint16(v); f32 = float32(u16); w = big(f32) case tu16100 + tf64: u16 = uint16(v); f64 = float64(u16); w = big(f64) case ti32100 + ti8: i32 = int32(v); i8 = int8(i32); w = big(i8) case ti32100 + tu8: i32 = int32(v); u8 = uint8(i32); w = big(u8) case ti32100 + ti16: i32 = int32(v); i16 = int16(i32); w = big(i16) case ti32100 + tu16: i32 = int32(v); u16 = uint16(i32); w = big(u16) case ti32100 + ti32: i32 = int32(v); i32 = int32(i32); w = big(i32) case ti32100 + tu32: i32 = int32(v); u32 = uint32(i32); w = big(u32) case ti32100 + ti64: i32 = int32(v); i64 = int64(i32); w = big(i64) case ti32100 + tu64: i32 = int32(v); u64 = uint64(i32); w = big(u64) case ti32100 + tf32: i32 = int32(v); f32 = float32(i32); w = big(f32) case ti32100 + tf64: i32 = int32(v); f64 = float64(i32); w = big(f64) case tu32100 + ti8: u32 = uint32(v); i8 = int8(u32); w = big(i8) case tu32100 + tu8: u32 = uint32(v); u8 = uint8(u32); w = big(u8) case tu32100 + ti16: u32 = uint32(v); i16 = int16(u32); w = big(i16) case tu32100 + tu16: u32 = uint32(v); u16 = uint16(u32); w = big(u16) case tu32100 + ti32: u32 = uint32(v); i32 = int32(u32); w = big(i32) case tu32100 + tu32: u32 = uint32(v); u32 = uint32(u32); w = big(u32) case tu32100 + ti64: u32 = uint32(v); i64 = int64(u32); w = big(i64) case tu32100 + tu64: u32 = uint32(v); u64 = uint64(u32); w = big(u64) case tu32100 + tf32: u32 = uint32(v); f32 = float32(u32); w = big(f32) case tu32100 + tf64: u32 = uint32(v); f64 = float64(u32); w = big(f64) case ti64100 + ti8: i64 = int64(v); i8 = int8(i64); w = big(i8) case ti64100 + tu8: i64 = int64(v); u8 = uint8(i64); w = big(u8) case ti64100 + ti16: i64 = int64(v); i16 = int16(i64); w = big(i16) case ti64100 + tu16: i64 = int64(v); u16 = uint16(i64); w = big(u16) case ti64100 + ti32: i64 = int64(v); i32 = int32(i64); w = big(i32) case ti64100 + tu32: i64 = int64(v); u32 = uint32(i64); w = big(u32) case ti64100 + ti64: i64 = int64(v); i64 = int64(i64); w = big(i64) case ti64100 + tu64: i64 = int64(v); u64 = uint64(i64); w = big(u64) case ti64100 + tf32: i64 = int64(v); f32 = float32(i64); w = big(f32) case ti64100 + tf64: i64 = int64(v); f64 = float64(i64); w = big(f64) case tu64100 + ti8: u64 = uint64(v); i8 = int8(u64); w = big(i8) case tu64100 + tu8: u64 = uint64(v); u8 = uint8(u64); w = big(u8) case tu64100 + ti16: u64 = uint64(v); i16 = int16(u64); w = big(i16) case tu64100 + tu16: u64 = uint64(v); u16 = uint16(u64); w = big(u16) case tu64100 + ti32: u64 = uint64(v); i32 = int32(u64); w = big(i32) case tu64100 + tu32: u64 = uint64(v); u32 = uint32(u64); w = big(u32) case tu64100 + ti64: u64 = uint64(v); i64 = int64(u64); w = big(i64) case tu64100 + tu64: u64 = uint64(v); u64 = uint64(u64); w = big(u64) case tu64100 + tf32: u64 = uint64(v); f32 = float32(u64); w = big(f32) case tu64100 + tf64: u64 = uint64(v); f64 = float64(u64); w = big(f64) case tf32100 + ti8: f32 = float32(v); i8 = int8(f32); w = big(i8) case tf32100 + tu8: f32 = float32(v); u8 = uint8(f32); w = big(u8) case tf32100 + ti16: f32 = float32(v); i16 = int16(f32); w = big(i16) case tf32100 + tu16: f32 = float32(v); u16 = uint16(f32); w = big(u16) case tf32100 + ti32: f32 = float32(v); i32 = int32(f32); w = big(i32) case tf32100 + tu32: f32 = float32(v); u32 = uint32(f32); w = big(u32) case tf32100 + ti64: f32 = float32(v); i64 = int64(f32); w = big(i64) case tf32100 + tu64: f32 = float32(v); u64 = uint64(f32); w = big(u64) case tf32100 + tf32: f32 = float32(v); f32 = float32(f32); w = big(f32) case tf32100 + tf64: f32 = float32(v); f64 = float64(f32); w = big(f64) case tf64100 + ti8: f64 = float64(v); i8 = int8(f64); w = big(i8) case tf64100 + tu8: f64 = float64(v); u8 = uint8(f64); w = big(u8) case tf64100 + ti16: f64 = float64(v); i16 = int16(f64); w = big(i16) case tf64100 + tu16: f64 = float64(v); u16 = uint16(f64); w = big(u16) case tf64100 + ti32: f64 = float64(v); i32 = int32(f64); w = big(i32) case tf64100 + tu32: f64 = float64(v); u32 = uint32(f64); w = big(u32) case tf64100 + ti64: f64 = float64(v); i64 = int64(f64); w = big(i64) case tf64100 + tu64: f64 = float64(v); u64 = uint64(f64); w = big(u64) case tf64100 + tf32: f64 = float64(v); f32 = float32(f64); w = big(f32) case tf64100 + tf64: f64 = float64(v); f64 = float64(f64); w = big(f64) } if v != w { println(i, v, w, f, t) } } }	14.94 KB	2024-02-02 18:09
📄 cplx0.go // run // Copyright 2010 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test trivial, bootstrap-level complex numbers, including printing. package main const ( R = 5 I = 6i C1 = R + I // ADD(5,6) ) func doprint(c complex128) { println(c) } func main() { // constants println(C1) doprint(C1) // variables c1 := C1 println(c1) doprint(c1) }	455 B	2024-02-02 18:09
📄 cplx0.out (+5.000000e+000+6.000000e+000i) (+5.000000e+000+6.000000e+000i) (+5.000000e+000+6.000000e+000i) (+5.000000e+000+6.000000e+000i)	128 B	2024-02-02 18:09
📄 cplx1.go // run // Copyright 2010 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test simple arithmetic and assignment for complex numbers. package main const ( R = 5 I = 6i C1 = R + I // ADD(5,6) ) func main() { var b bool // constants b = (5 + 6i) == C1 if !b { println("const bool 1", b) panic("fail") } b = (5 + 6i) != C1 if b { println("const bool 2", b) panic("fail") } b = C1 == (5 + 6i) if !b { println("const bool 3", b) panic("fail") } b = C1 != (5 + 6i) if b { println("const bool 4", b) panic("fail") } // vars passed through parameters booltest(5+6i, true) booltest(5+7i, false) booltest(6+6i, false) booltest(6+9i, false) } func booltest(a complex64, r bool) { var b bool b = a == C1 if b != r { println("param bool 1", a, b, r) panic("fail") } b = a != C1 if b == r { println("param bool 2", a, b, r) panic("fail") } b = C1 == a if b != r { println("param bool 3", a, b, r) panic("fail") } b = C1 != a if b == r { println("param bool 4", a, b, r) panic("fail") } if r { if a != C1 { println("param bool 5", a, b, r) panic("fail") } if C1 != a { println("param bool 6", a, b, r) panic("fail") } } else { if a == C1 { println("param bool 6", a, b, r) panic("fail") } if C1 == a { println("param bool 7", a, b, r) panic("fail") } } }	1.43 KB	2024-02-02 18:09
📄 cplx2.go // run // Copyright 2010 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test arithmetic on complex numbers, including multiplication and division. package main const ( R = 5 I = 6i C1 = R + I // ADD(5,6) C2 = R - I // SUB(5,-6) C3 = -(R + I) // ADD(5,6) NEG(-5,-6) C4 = -(R - I) // SUB(5,-6) NEG(-5,6) C5 = C1 + R // ADD(10,6) C6 = C1 + I // ADD(5,12) Ca = C5 + C6 // ADD(15,18) Cb = C5 - C6 // SUB(5,-6) Cc = C5 * C6 // MUL(-22,-150) Cd = C5 / C6 // DIV(0.721893,-0.532544) Ce = Cd * C6 // MUL(10,6) sb C5 ) func main() { var r complex64 = 5 + 0i if r != R { println("opcode 1", r, R) panic("fail") } var i complex64 = 6i if i != I { println("opcode 2", i, I) panic("fail") } c1 := r + i if c1 != C1 { println("opcode x", c1, C1) panic("fail") } c2 := r - i if c2 != C2 { println("opcode x", c2, C2) panic("fail") } c3 := -(r + i) if c3 != C3 { println("opcode x", c3, C3) panic("fail") } c4 := -(r - i) if c4 != C4 { println("opcode x", c4, C4) panic("fail") } c5 := c1 + r if c5 != C5 { println("opcode x", c5, C5) panic("fail") } c6 := c1 + i if c6 != C6 { println("opcode x", c6, C6) panic("fail") } ca := c5 + c6 if ca != Ca { println("opcode x", ca, Ca) panic("fail") } cb := c5 - c6 if cb != Cb { println("opcode x", cb, Cb) panic("fail") } cc := c5 * c6 if cc != Cc { println("opcode x", cc, Cc) panic("fail") } cd := c5 / c6 if cd != Cd { println("opcode x", cd, Cd) panic("fail") } ce := cd * c6 if ce != Ce { println("opcode x", ce, Ce) panic("fail") } r32 := real(complex64(ce)) if r32 != float32(real(Ce)) { println("real(complex64(ce))", r32, real(Ce)) panic("fail") } r64 := real(complex128(ce)) if r64 != real(Ce) { println("real(complex128(ce))", r64, real(Ce)) panic("fail") } }	1.9 KB	2024-02-02 18:09
📄 cplx3.go // run // Copyright 2010 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test composition, decomposition, and reflection on complex numbers. package main import "unsafe" import "reflect" const ( R = 5 I = 6i C1 = R + I // ADD(5,6) ) func main() { c0 := C1 c0 = (c0 + c0 + c0) / (c0 + c0 + 3i) r, i := real(c0), imag(c0) d := r - 1.292308 if d < 0 { d = - d } if d > 1e-6 { println(r, "!= 1.292308") panic(0) } d = i + 0.1384615 if d < 0 { d = - d } if d > 1e-6 { println(i, "!= -0.1384615") panic(0) } c := (complex128)(unsafe.Pointer(&c0)) if c != c0 { println(c, "!=", c) panic(0) } var a interface{} switch c := reflect.ValueOf(a); c.Kind() { case reflect.Complex64, reflect.Complex128: v := c.Complex() _, _ = complex128(v), true } }	888 B	2024-02-02 18:09
📄 cplx4.go // run // Copyright 2010 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test complex numbers,including fmt support. // Used to crash. package main import "fmt" const ( R = 5 I = 6i C1 = R + I // ADD(5,6) ) func want(s, w string) { if s != w { panic(s + " != " + w) } } func doprint(c complex128, w string) { s := fmt.Sprintf("%f", c) want(s, w) } func main() { // constants s := fmt.Sprintf("%f", -C1) want(s, "(-5.000000-6.000000i)") doprint(C1, "(5.000000+6.000000i)") // variables c1 := C1 s = fmt.Sprintf("%f", c1) want(s, "(5.000000+6.000000i)") doprint(c1, "(5.000000+6.000000i)") // 128 c2 := complex128(C1) s = fmt.Sprintf("%G", c2) want(s, "(5+6i)") // real, imag, complex c3 := complex(real(c2)+3, imag(c2)-5) + c2 s = fmt.Sprintf("%G", c3) want(s, "(13+7i)") // compiler used to crash on nested divide c4 := complex(real(c3/2), imag(c3/2)) if c4 != c3/2 { fmt.Printf("BUG: c3 = %G != c4 = %G\n", c3, c4) panic(0) } }	1.05 KB	2024-02-02 18:09
📄 cplx5.go // run // Copyright 2010 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test compound types made of complex numbers. package main var a [12]complex128 var s []complex128 var c chan complex128 var f struct { c complex128 } var m map[complex128]complex128 func main() { // array of complex128 for i := 0; i < len(a); i++ { a[i] = complex(float64(i), float64(-i)) } if a[5] != 5-5i { panic(a[5]) } // slice of complex128 s = make([]complex128, len(a)) for i := 0; i < len(s); i++ { s[i] = a[i] } if s[5] != 5-5i { panic(s[5]) } // chan c = make(chan complex128) go chantest(c) vc := <-c if vc != 5-5i { panic(vc) } // pointer of complex128 v := a[5] pv := &v if pv != 5-5i { panic(pv) } // field of complex128 f.c = a[5] if f.c != 5-5i { panic(f.c) } // map of complex128 m = make(map[complex128]complex128) for i := 0; i < len(s); i++ { m[-a[i]] = a[i] } if m[5i-5] != 5-5i { panic(m[5i-5]) } vm := m[complex(-5, 5)] if vm != 5-5i { panic(vm) } } func chantest(c chan complex128) { c <- a[5] }	1.13 KB	2024-02-02 18:09
📄 divconst.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test integer division by constants. package main import "math/rand" const Count = 1e5 func i64rand() int64 { for { a := int64(rand.Uint32()) a = (a << 32) \| int64(rand.Uint32()) a >>= uint(rand.Intn(64)) if -a != a { return a } } return 0 // impossible } func i64test(a, b, c int64) { d := a / c if d != b { println("i64", a, b, c, d) panic("fail") } } func i64run() { var a, b int64 for i := 0; i < Count; i++ { a = i64rand() b = a / 1 i64test(a, b, 1) b = a / 2 i64test(a, b, 2) b = a / 3 i64test(a, b, 3) b = a / 4 i64test(a, b, 4) b = a / 5 i64test(a, b, 5) b = a / 6 i64test(a, b, 6) b = a / 7 i64test(a, b, 7) b = a / 8 i64test(a, b, 8) b = a / 10 i64test(a, b, 10) b = a / 16 i64test(a, b, 16) b = a / 20 i64test(a, b, 20) b = a / 32 i64test(a, b, 32) b = a / 60 i64test(a, b, 60) b = a / 64 i64test(a, b, 64) b = a / 128 i64test(a, b, 128) b = a / 256 i64test(a, b, 256) b = a / 16384 i64test(a, b, 16384) b = a / -1 i64test(a, b, -1) b = a / -2 i64test(a, b, -2) b = a / -3 i64test(a, b, -3) b = a / -4 i64test(a, b, -4) b = a / -5 i64test(a, b, -5) b = a / -6 i64test(a, b, -6) b = a / -7 i64test(a, b, -7) b = a / -8 i64test(a, b, -8) b = a / -10 i64test(a, b, -10) b = a / -16 i64test(a, b, -16) b = a / -20 i64test(a, b, -20) b = a / -32 i64test(a, b, -32) b = a / -60 i64test(a, b, -60) b = a / -64 i64test(a, b, -64) b = a / -128 i64test(a, b, -128) b = a / -256 i64test(a, b, -256) b = a / -16384 i64test(a, b, -16384) } } func u64rand() uint64 { a := uint64(rand.Uint32()) a = (a << 32) \| uint64(rand.Uint32()) a >>= uint(rand.Intn(64)) return a } func u64test(a, b, c uint64) { d := a / c if d != b { println("u64", a, b, c, d) panic("fail") } } func u64run() { var a, b uint64 for i := 0; i < Count; i++ { a = u64rand() b = a / 1 u64test(a, b, 1) b = a / 2 u64test(a, b, 2) b = a / 3 u64test(a, b, 3) b = a / 4 u64test(a, b, 4) b = a / 5 u64test(a, b, 5) b = a / 6 u64test(a, b, 6) b = a / 7 u64test(a, b, 7) b = a / 8 u64test(a, b, 8) b = a / 10 u64test(a, b, 10) b = a / 16 u64test(a, b, 16) b = a / 20 u64test(a, b, 20) b = a / 32 u64test(a, b, 32) b = a / 60 u64test(a, b, 60) b = a / 64 u64test(a, b, 64) b = a / 128 u64test(a, b, 128) b = a / 256 u64test(a, b, 256) b = a / 16384 u64test(a, b, 16384) } } func i32rand() int32 { for { a := int32(rand.Uint32()) a >>= uint(rand.Intn(32)) if -a != a { return a } } return 0 // impossible } func i32test(a, b, c int32) { d := a / c if d != b { println("i32", a, b, c, d) panic("fail") } } func i32run() { var a, b int32 for i := 0; i < Count; i++ { a = i32rand() b = a / 1 i32test(a, b, 1) b = a / 2 i32test(a, b, 2) b = a / 3 i32test(a, b, 3) b = a / 4 i32test(a, b, 4) b = a / 5 i32test(a, b, 5) b = a / 6 i32test(a, b, 6) b = a / 7 i32test(a, b, 7) b = a / 8 i32test(a, b, 8) b = a / 10 i32test(a, b, 10) b = a / 16 i32test(a, b, 16) b = a / 20 i32test(a, b, 20) b = a / 32 i32test(a, b, 32) b = a / 60 i32test(a, b, 60) b = a / 64 i32test(a, b, 64) b = a / 128 i32test(a, b, 128) b = a / 256 i32test(a, b, 256) b = a / 16384 i32test(a, b, 16384) b = a / -1 i32test(a, b, -1) b = a / -2 i32test(a, b, -2) b = a / -3 i32test(a, b, -3) b = a / -4 i32test(a, b, -4) b = a / -5 i32test(a, b, -5) b = a / -6 i32test(a, b, -6) b = a / -7 i32test(a, b, -7) b = a / -8 i32test(a, b, -8) b = a / -10 i32test(a, b, -10) b = a / -16 i32test(a, b, -16) b = a / -20 i32test(a, b, -20) b = a / -32 i32test(a, b, -32) b = a / -60 i32test(a, b, -60) b = a / -64 i32test(a, b, -64) b = a / -128 i32test(a, b, -128) b = a / -256 i32test(a, b, -256) } } func u32rand() uint32 { a := uint32(rand.Uint32()) a >>= uint(rand.Intn(32)) return a } func u32test(a, b, c uint32) { d := a / c if d != b { println("u32", a, b, c, d) panic("fail") } } func u32run() { var a, b uint32 for i := 0; i < Count; i++ { a = u32rand() b = a / 1 u32test(a, b, 1) b = a / 2 u32test(a, b, 2) b = a / 3 u32test(a, b, 3) b = a / 4 u32test(a, b, 4) b = a / 5 u32test(a, b, 5) b = a / 6 u32test(a, b, 6) b = a / 7 u32test(a, b, 7) b = a / 8 u32test(a, b, 8) b = a / 10 u32test(a, b, 10) b = a / 16 u32test(a, b, 16) b = a / 20 u32test(a, b, 20) b = a / 32 u32test(a, b, 32) b = a / 60 u32test(a, b, 60) b = a / 64 u32test(a, b, 64) b = a / 128 u32test(a, b, 128) b = a / 256 u32test(a, b, 256) b = a / 16384 u32test(a, b, 16384) } } func i16rand() int16 { for { a := int16(rand.Uint32()) a >>= uint(rand.Intn(16)) if -a != a { return a } } return 0 // impossible } func i16test(a, b, c int16) { d := a / c if d != b { println("i16", a, b, c, d) panic("fail") } } func i16run() { var a, b int16 for i := 0; i < Count; i++ { a = i16rand() b = a / 1 i16test(a, b, 1) b = a / 2 i16test(a, b, 2) b = a / 3 i16test(a, b, 3) b = a / 4 i16test(a, b, 4) b = a / 5 i16test(a, b, 5) b = a / 6 i16test(a, b, 6) b = a / 7 i16test(a, b, 7) b = a / 8 i16test(a, b, 8) b = a / 10 i16test(a, b, 10) b = a / 16 i16test(a, b, 16) b = a / 20 i16test(a, b, 20) b = a / 32 i16test(a, b, 32) b = a / 60 i16test(a, b, 60) b = a / 64 i16test(a, b, 64) b = a / 128 i16test(a, b, 128) b = a / 256 i16test(a, b, 256) b = a / 16384 i16test(a, b, 16384) b = a / -1 i16test(a, b, -1) b = a / -2 i16test(a, b, -2) b = a / -3 i16test(a, b, -3) b = a / -4 i16test(a, b, -4) b = a / -5 i16test(a, b, -5) b = a / -6 i16test(a, b, -6) b = a / -7 i16test(a, b, -7) b = a / -8 i16test(a, b, -8) b = a / -10 i16test(a, b, -10) b = a / -16 i16test(a, b, -16) b = a / -20 i16test(a, b, -20) b = a / -32 i16test(a, b, -32) b = a / -60 i16test(a, b, -60) b = a / -64 i16test(a, b, -64) b = a / -128 i16test(a, b, -128) b = a / -256 i16test(a, b, -256) b = a / -16384 i16test(a, b, -16384) } } func u16rand() uint16 { a := uint16(rand.Uint32()) a >>= uint(rand.Intn(16)) return a } func u16test(a, b, c uint16) { d := a / c if d != b { println("u16", a, b, c, d) panic("fail") } } func u16run() { var a, b uint16 for i := 0; i < Count; i++ { a = u16rand() b = a / 1 u16test(a, b, 1) b = a / 2 u16test(a, b, 2) b = a / 3 u16test(a, b, 3) b = a / 4 u16test(a, b, 4) b = a / 5 u16test(a, b, 5) b = a / 6 u16test(a, b, 6) b = a / 7 u16test(a, b, 7) b = a / 8 u16test(a, b, 8) b = a / 10 u16test(a, b, 10) b = a / 16 u16test(a, b, 16) b = a / 20 u16test(a, b, 20) b = a / 32 u16test(a, b, 32) b = a / 60 u16test(a, b, 60) b = a / 64 u16test(a, b, 64) b = a / 128 u16test(a, b, 128) b = a / 256 u16test(a, b, 256) b = a / 16384 u16test(a, b, 16384) } } func i8rand() int8 { for { a := int8(rand.Uint32()) a >>= uint(rand.Intn(8)) if -a != a { return a } } return 0 // impossible } func i8test(a, b, c int8) { d := a / c if d != b { println("i8", a, b, c, d) panic("fail") } } func i8run() { var a, b int8 for i := 0; i < Count; i++ { a = i8rand() b = a / 1 i8test(a, b, 1) b = a / 2 i8test(a, b, 2) b = a / 3 i8test(a, b, 3) b = a / 4 i8test(a, b, 4) b = a / 5 i8test(a, b, 5) b = a / 6 i8test(a, b, 6) b = a / 7 i8test(a, b, 7) b = a / 8 i8test(a, b, 8) b = a / 10 i8test(a, b, 10) b = a / 8 i8test(a, b, 8) b = a / 20 i8test(a, b, 20) b = a / 32 i8test(a, b, 32) b = a / 60 i8test(a, b, 60) b = a / 64 i8test(a, b, 64) b = a / 127 i8test(a, b, 127) b = a / -1 i8test(a, b, -1) b = a / -2 i8test(a, b, -2) b = a / -3 i8test(a, b, -3) b = a / -4 i8test(a, b, -4) b = a / -5 i8test(a, b, -5) b = a / -6 i8test(a, b, -6) b = a / -7 i8test(a, b, -7) b = a / -8 i8test(a, b, -8) b = a / -10 i8test(a, b, -10) b = a / -8 i8test(a, b, -8) b = a / -20 i8test(a, b, -20) b = a / -32 i8test(a, b, -32) b = a / -60 i8test(a, b, -60) b = a / -64 i8test(a, b, -64) b = a / -128 i8test(a, b, -128) } } func u8rand() uint8 { a := uint8(rand.Uint32()) a >>= uint(rand.Intn(8)) return a } func u8test(a, b, c uint8) { d := a / c if d != b { println("u8", a, b, c, d) panic("fail") } } func u8run() { var a, b uint8 for i := 0; i < Count; i++ { a = u8rand() b = a / 1 u8test(a, b, 1) b = a / 2 u8test(a, b, 2) b = a / 3 u8test(a, b, 3) b = a / 4 u8test(a, b, 4) b = a / 5 u8test(a, b, 5) b = a / 6 u8test(a, b, 6) b = a / 7 u8test(a, b, 7) b = a / 8 u8test(a, b, 8) b = a / 10 u8test(a, b, 10) b = a / 8 u8test(a, b, 8) b = a / 20 u8test(a, b, 20) b = a / 32 u8test(a, b, 32) b = a / 60 u8test(a, b, 60) b = a / 64 u8test(a, b, 64) b = a / 128 u8test(a, b, 128) b = a / 184 u8test(a, b, 184) } } func main() { xtest() i64run() u64run() i32run() u32run() i16run() u16run() i8run() u8run() } func xtest() { }	9.23 KB	2024-02-02 18:09
📄 divmod.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test integer division and modulus. package main const ( // example from the spec n1 = +5 n2 = -5 d1 = +3 d2 = -3 q1 = +1 q2 = -1 q3 = -1 q4 = +1 r1 = +2 r2 = -2 r3 = +2 r4 = -2 ) func main() { /* ideals / if n1/d1 != q1 \|\| n1%d1 != r1 { println("ideal-1", n1, d1, n1/d1, n1%d1) panic("fail") } if n2/d1 != q2 \|\| n2%d1 != r2 { println("ideal-2", n2, d1, n2/d1, n2%d1) panic("fail") } if n1/d2 != q3 \|\| n1%d2 != r3 { println("ideal-3", n1, d2, n1/d2, n1%d2) panic("fail") } if n2/d2 != q4 \|\| n2%d2 != r4 { println("ideal-4", n2, d2, n2/d2, n2%d2) panic("fail") } / int / var in1 int = +5 var in2 int = -5 var id1 int = +3 var id2 int = -3 if in1/id1 != q1 \|\| in1%id1 != r1 { println("int-1", in1, id1, in1/id1, in1%id1) panic("fail") } if in2/id1 != q2 \|\| in2%id1 != r2 { println("int-2", in2, id1, in2/id1, in2%id1) panic("fail") } if in1/id2 != q3 \|\| in1%id2 != r3 { println("int-3", in1, id2, in1/id2, in1%id2) panic("fail") } if in2/id2 != q4 \|\| in2%id2 != r4 { println("int-4", in2, id2, in2/id2, in2%id2) panic("fail") } / int8 / var bn1 int8 = +5 var bn2 int8 = -5 var bd1 int8 = +3 var bd2 int8 = -3 if bn1/bd1 != q1 \|\| bn1%bd1 != r1 { println("int8-1", bn1, bd1, bn1/bd1, bn1%bd1) panic("fail") } if bn2/bd1 != q2 \|\| bn2%bd1 != r2 { println("int8-2", bn2, bd1, bn2/bd1, bn2%bd1) panic("fail") } if bn1/bd2 != q3 \|\| bn1%bd2 != r3 { println("int8-3", bn1, bd2, bn1/bd2, bn1%bd2) panic("fail") } if bn2/bd2 != q4 \|\| bn2%bd2 != r4 { println("int8-4", bn2, bd2, bn2/bd2, bn2%bd2) panic("fail") } / int16 / var sn1 int16 = +5 var sn2 int16 = -5 var sd1 int16 = +3 var sd2 int16 = -3 if sn1/sd1 != q1 \|\| sn1%sd1 != r1 { println("int16-1", sn1, sd1, sn1/sd1, sn1%sd1) panic("fail") } if sn2/sd1 != q2 \|\| sn2%sd1 != r2 { println("int16-2", sn2, sd1, sn2/sd1, sn2%sd1) panic("fail") } if sn1/sd2 != q3 \|\| sn1%sd2 != r3 { println("int16-3", sn1, sd2, sn1/sd2, sn1%sd2) panic("fail") } if sn2/sd2 != q4 \|\| sn2%sd2 != r4 { println("int16-4", sn2, sd2, sn2/sd2, sn2%sd2) panic("fail") } / int32 / var ln1 int32 = +5 var ln2 int32 = -5 var ld1 int32 = +3 var ld2 int32 = -3 if ln1/ld1 != q1 \|\| ln1%ld1 != r1 { println("int32-1", ln1, ld1, ln1/ld1, ln1%ld1) panic("fail") } if ln2/ld1 != q2 \|\| ln2%ld1 != r2 { println("int32-2", ln2, ld1, ln2/ld1, ln2%ld1) panic("fail") } if ln1/ld2 != q3 \|\| ln1%ld2 != r3 { println("int32-3", ln1, ld2, ln1/ld2, ln1%ld2) panic("fail") } if ln2/ld2 != q4 \|\| ln2%ld2 != r4 { println("int32-4", ln2, ld2, ln2/ld2, ln2%ld2) panic("fail") } / int64 / var qn1 int64 = +5 var qn2 int64 = -5 var qd1 int64 = +3 var qd2 int64 = -3 if qn1/qd1 != q1 \|\| qn1%qd1 != r1 { println("int64-1", qn1, qd1, qn1/qd1, qn1%qd1) panic("fail") } if qn2/qd1 != q2 \|\| qn2%qd1 != r2 { println("int64-2", qn2, qd1, qn2/qd1, qn2%qd1) panic("fail") } if qn1/qd2 != q3 \|\| qn1%qd2 != r3 { println("int64-3", qn1, qd2, qn1/qd2, qn1%qd2) panic("fail") } if qn2/qd2 != q4 \|\| qn2%qd2 != r4 { println("int64-4", qn2, qd2, qn2/qd2, qn2%qd2) panic("fail") } if n1/qd1 != q1 \|\| n1%qd1 != r1 { println("mixed int64-1", n1, qd1, n1/qd1, n1%qd1) panic("fail") } if n2/qd1 != q2 \|\| n2%qd1 != r2 { println("mixed int64-2", n2, qd1, n2/qd1, n2%qd1) panic("fail") } if n1/qd2 != q3 \|\| n1%qd2 != r3 { println("mixed int64-3", n1, qd2, n1/qd2, n1%qd2) panic("fail") } if n2/qd2 != q4 \|\| n2%qd2 != r4 { println("mixed int64-4", n2, qd2, n2/qd2, n2%qd2) panic("fail") } if qn1/d1 != q1 \|\| qn1%d1 != r1 { println("mixed int64-5", qn1, d1, qn1/d1, qn1%d1) panic("fail") } if qn2/d1 != q2 \|\| qn2%d1 != r2 { println("mixed int64-6", qn2, d1, qn2/d1, qn2%d1) panic("fail") } if qn1/d2 != q3 \|\| qn1%d2 != r3 { println("mixed int64-7", qn1, d2, qn1/d2, qn1%d2) panic("fail") } if qn2/d2 != q4 \|\| qn2%d2 != r4 { println("mixed int64-8", qn2, d2, qn2/d2, qn2%d2) panic("fail") } / uint / var uin1 uint = +5 var uid1 uint = +3 if uin1/uid1 != q1 \|\| uin1%uid1 != r1 { println("uint", uin1, uid1, uin1/uid1, uin1%uid1) panic("fail") } / uint8 / var ubn1 uint8 = +5 var ubd1 uint8 = +3 if ubn1/ubd1 != q1 \|\| ubn1%ubd1 != r1 { println("uint8", ubn1, ubd1, ubn1/ubd1, ubn1%ubd1) panic("fail") } / uint16 / var usn1 uint16 = +5 var usd1 uint16 = +3 if usn1/usd1 != q1 \|\| usn1%usd1 != r1 { println("uint16", usn1, usd1, usn1/usd1, usn1%usd1) panic("fail") } / uint32 / var uln1 uint32 = +5 var uld1 uint32 = +3 if uln1/uld1 != q1 \|\| uln1%uld1 != r1 { println("uint32", uln1, uld1, uln1/uld1, uln1%uld1) panic("fail") } / uint64 */ var uqn1 uint64 = +5 var uqd1 uint64 = +3 if uqn1/uqd1 != q1 \|\| uqn1%uqd1 != r1 { println("uint64", uqn1, uqd1, uqn1/uqd1, uqn1%uqd1) panic("fail") } if n1/uqd1 != q1 \|\| n1%uqd1 != r1 { println("mixed uint64-1", n1, uqd1, n1/uqd1, n1%uqd1) panic("fail") } if uqn1/d1 != q1 \|\| uqn1%d1 != r1 { println("mixed uint64-2", uqn1, d1, uqn1/d1, uqn1%d1) panic("fail") } }	5.13 KB	2024-02-02 18:09
📄 embed.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test embedded fields of structs, including methods. package main type I interface { test1() int test2() int test3() int test4() int test5() int test6() int test7() int } /**** ** ***/ type SubpSubp struct { a7 int a int } func (p SubpSubp) test7() int { if p.a != p.a7 { println("SubpSubp", p, p.a7) panic("fail") } return p.a } func (p SubpSubp) testx() { println("SubpSubp", p, p.a7) } /*** ** ***/ type SubpSub struct { a6 int SubpSubp a int } func (p SubpSub) test6() int { if p.a != p.a6 { println("SubpSub", p, p.a6) panic("fail") } return p.a } func (p SubpSub) testx() { println("SubpSub", p, p.a6) } /*** ** ***/ type SubSubp struct { a5 int a int } func (p SubSubp) test5() int { if p.a != p.a5 { println("SubpSub", p, p.a5) panic("fail") } return p.a } /**** ** ***/ type SubSub struct { a4 int a int } func (p SubSub) test4() int { if p.a != p.a4 { println("SubpSub", p, p.a4) panic("fail") } return p.a } /**** ** ***/ type Subp struct { a3 int SubpSubp SubpSub a int } func (p Subp) test3() int { if p.a != p.a3 { println("SubpSub", p, p.a3) panic("fail") } return p.a } /*** ** ***/ type Sub struct { a2 int SubSubp SubSub a int } func (p Sub) test2() int { if p.a != p.a2 { println("SubpSub", p, p.a2) panic("fail") } return p.a } /*** ** ***/ type S struct { a1 int Sub Subp a int } func (p S) test1() int { if p.a != p.a1 { println("SubpSub", p, p.a1) panic("fail") } return p.a } /*** ** ***/ func main() { var i I var s S // allocate s = new(S) s.Subp = new(Subp) s.Sub.SubSubp = new(SubSubp) s.Subp.SubpSubp = new(SubpSubp) // explicit assignment s.a = 1 s.Sub.a = 2 s.Subp.a = 3 s.Sub.SubSub.a = 4 s.Sub.SubSubp.a = 5 s.Subp.SubpSub.a = 6 s.Subp.SubpSubp.a = 7 // embedded (unique) assignment s.a1 = 1 s.a2 = 2 s.a3 = 3 s.a4 = 4 s.a5 = 5 s.a6 = 6 s.a7 = 7 // unique calls with explicit & if s.test1() != 1 { println("t1", 1) panic("fail") } if (&s.Sub).test2() != 2 { println("t1", 2) panic("fail") } if s.Subp.test3() != 3 { println("t1", 3) panic("fail") } if (&s.Sub.SubSub).test4() != 4 { println("t1", 4) panic("fail") } if s.Sub.SubSubp.test5() != 5 { println("t1", 5) panic("fail") } if (&s.Subp.SubpSub).test6() != 6 { println("t1", 6) panic("fail") } if s.Subp.SubpSubp.test7() != 7 { println("t1", 7) panic("fail") } // automatic & if s.Sub.test2() != 2 { println("t2", 2) panic("fail") } if s.Sub.SubSub.test4() != 4 { println("t2", 4) panic("fail") } if s.Subp.SubpSub.test6() != 6 { println("t2", 6) panic("fail") } // embedded calls if s.test1() != s.a1 { println("t3", 1) panic("fail") } if s.test2() != s.a2 { println("t3", 2) panic("fail") } if s.test3() != s.a3 { println("t3", 3) panic("fail") } if s.test4() != s.a4 { println("t3", 4) panic("fail") } if s.test5() != s.a5 { println("t3", 5) panic("fail") } if s.test6() != s.a6 { println("t3", 6) panic("fail") } if s.test7() != s.a7 { println("t3", 7) panic("fail") } // run it through an interface i = s s = i.(*S) // same as t3 if s.test1() != s.a1 { println("t4", 1) panic("fail") } if s.test2() != s.a2 { println("t4", 2) panic("fail") } if s.test3() != s.a3 { println("t4", 3) panic("fail") } if s.test4() != s.a4 { println("t4", 4) panic("fail") } if s.test5() != s.a5 { println("t4", 5) panic("fail") } if s.test6() != s.a6 { println("t4", 6) panic("fail") } if s.test7() != s.a7 { println("t4", 7) panic("fail") } // call interface if i.test1() != s.test1() { println("t5", 1) panic("fail") } if i.test2() != s.test2() { println("t5", 2) panic("fail") } if i.test3() != s.test3() { println("t5", 3) panic("fail") } if i.test4() != s.test4() { println("t5", 4) panic("fail") } if i.test5() != s.test5() { println("t5", 5) panic("fail") } if i.test6() != s.test6() { println("t5", 6) panic("fail") } if i.test7() != s.test7() { println("t5", 7) panic("fail") } }	4.27 KB	2024-02-02 18:09
📄 for.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test simple for loop. package main func main() { var t,i int; for i=0; i<100; i=i+1 { t = t+i; } if t != 50*99 { panic(t); } }	308 B	2024-02-02 18:09
📄 interbasic.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test interfaces on basic types. package main type myint int type mystring string type I0 interface{} func f() { var ia, ib I0 var i myint var s mystring if ia != ib { panic("1") } i = 1 ia = i ib = i if ia != ib { panic("2") } if ia == nil { panic("3") } i = 2 ia = i if ia == ib { panic("4") } ia = nil if ia == ib { panic("5") } ib = nil if ia != ib { panic("6") } if ia != nil { panic("7") } s = "abc" ia = s ib = nil if ia == ib { panic("8") } s = "def" ib = s if ia == ib { panic("9") } s = "abc" ib = s if ia != ib { panic("a") } } func main() { var ia [20]I0 var b bool var s string var i8 int8 var i16 int16 var i32 int32 var i64 int64 var u8 uint8 var u16 uint16 var u32 uint32 var u64 uint64 f() ia[0] = "xxx" ia[1] = 12345 ia[2] = true s = "now is" ia[3] = s b = false ia[4] = b i8 = 29 ia[5] = i8 i16 = 994 ia[6] = i16 i32 = 3434 ia[7] = i32 i64 = 1234567 ia[8] = i64 u8 = 12 ia[9] = u8 u16 = 799 ia[10] = u16 u32 = 4455 ia[11] = u32 u64 = 765432 ia[12] = u64 s = ia[0].(string) if s != "xxx" { println(0, s) panic("fail") } i32 = int32(ia[1].(int)) if i32 != 12345 { println(1, i32) panic("fail") } b = ia[2].(bool) if b != true { println(2, b) panic("fail") } s = ia[3].(string) if s != "now is" { println(3, s) panic("fail") } b = ia[4].(bool) if b != false { println(4, b) panic("fail") } i8 = ia[5].(int8) if i8 != 29 { println(5, i8) panic("fail") } i16 = ia[6].(int16) if i16 != 994 { println(6, i16) panic("fail") } i32 = ia[7].(int32) if i32 != 3434 { println(7, i32) panic("fail") } i64 = ia[8].(int64) if i64 != 1234567 { println(8, i64) panic("fail") } u8 = ia[9].(uint8) if u8 != 12 { println(5, u8) panic("fail") } u16 = ia[10].(uint16) if u16 != 799 { println(6, u16) panic("fail") } u32 = ia[11].(uint32) if u32 != 4455 { println(7, u32) panic("fail") } u64 = ia[12].(uint64) if u64 != 765432 { println(8, u64) panic("fail") } }	2.18 KB	2024-02-02 18:09
📄 interfun.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test interfaces and methods. package main type S struct { a,b int; } type I1 interface { f ()int; } type I2 interface { g() int; f() int; } func (this S) f()int { return this.a; } func (this S) g()int { return this.b; } func main() { var i1 I1; var i2 I2; var g S; s := new(S); s.a = 5; s.b = 6; // call structure if s.f() != 5 { panic(11); } if s.g() != 6 { panic(12); } i1 = s; // convert S to I1 i2 = i1.(I2); // convert I1 to I2 // call interface if i1.f() != 5 { panic(21); } if i2.f() != 5 { panic(22); } if i2.g() != 6 { panic(23); } g = i1.(S); // convert I1 to S if g != s { panic(31); } g = i2.(*S); // convert I2 to S if g != s { panic(32); } }	872 B	2024-02-02 18:09
📄 intervar.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test interface assignment. package main type Iputs interface { puts (s string) string; } // --------- type Print struct { whoami int; put Iputs; } func (p Print) dop() string { r := " print " + string(p.whoami + '0') return r + p.put.puts("abc"); } // --------- type Bio struct { whoami int; put Iputs; } func (b Bio) puts(s string) string { r := " bio " + string(b.whoami + '0') return r + b.put.puts(s); } // --------- type File struct { whoami int; put Iputs; } func (f *File) puts(s string) string { return " file " + string(f.whoami + '0') + " -- " + s } func main() { p := new(Print); b := new(Bio); f := new(File); p.whoami = 1; p.put = b; b.whoami = 2; b.put = f; f.whoami = 3; r := p.dop(); expected := " print 1 bio 2 file 3 -- abc" if r != expected { panic(r + " != " + expected) } }	1010 B	2024-02-02 18:09
📄 label.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test goto and labels. package main func main() { i := 0 if false { goto gogoloop } if false { goto gogoloop } if false { goto gogoloop } goto gogoloop // backward declared loop: i = i + 1 if i < 100 { goto loop } return gogoloop: goto loop }	439 B	2024-02-02 18:09
📄 litfun.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test simple function literals. package main func main() { x := func(a int)int { x := func(a int)int { x := func(a int)int { return a+5; }; return x(a)+7; }; return x(a)+11; }; if x(3) != 3+5+7+11 { panic(x(3)); } }	410 B	2024-02-02 18:09
📄 mfunc.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test simple multi-argument multi-valued function. package main func main() { var x,y int; x,y = simple(10,20,30); if x+y != 65 { panic(x+y); } } func simple(ia,ib,ic int) (oa,ob int) { return ia+5, ib+ic; }	386 B	2024-02-02 18:09
📄 modconst.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test integer modulus by constants. package main import "math/rand" const Count = 1e5 func i64rand() int64 { for { a := int64(rand.Uint32()) a = (a << 32) \| int64(rand.Uint32()) a >>= uint(rand.Intn(64)) if -a != a { return a } } return 0 // impossible } func i64test(a, b, c int64) { d := a % c if d != b { println("i64", a, b, c, d) panic("fail") } } func i64run() { var a, b int64 for i := 0; i < Count; i++ { a = i64rand() b = a % 1 i64test(a, b, 1) b = a % 2 i64test(a, b, 2) b = a % 3 i64test(a, b, 3) b = a % 4 i64test(a, b, 4) b = a % 5 i64test(a, b, 5) b = a % 6 i64test(a, b, 6) b = a % 7 i64test(a, b, 7) b = a % 8 i64test(a, b, 8) b = a % 10 i64test(a, b, 10) b = a % 16 i64test(a, b, 16) b = a % 20 i64test(a, b, 20) b = a % 32 i64test(a, b, 32) b = a % 60 i64test(a, b, 60) b = a % 64 i64test(a, b, 64) b = a % 128 i64test(a, b, 128) b = a % 256 i64test(a, b, 256) b = a % 16384 i64test(a, b, 16384) b = a % -1 i64test(a, b, -1) b = a % -2 i64test(a, b, -2) b = a % -3 i64test(a, b, -3) b = a % -4 i64test(a, b, -4) b = a % -5 i64test(a, b, -5) b = a % -6 i64test(a, b, -6) b = a % -7 i64test(a, b, -7) b = a % -8 i64test(a, b, -8) b = a % -10 i64test(a, b, -10) b = a % -16 i64test(a, b, -16) b = a % -20 i64test(a, b, -20) b = a % -32 i64test(a, b, -32) b = a % -60 i64test(a, b, -60) b = a % -64 i64test(a, b, -64) b = a % -128 i64test(a, b, -128) b = a % -256 i64test(a, b, -256) b = a % -16384 i64test(a, b, -16384) } } func u64rand() uint64 { a := uint64(rand.Uint32()) a = (a << 32) \| uint64(rand.Uint32()) a >>= uint(rand.Intn(64)) return a } func u64test(a, b, c uint64) { d := a % c if d != b { println("u64", a, b, c, d) panic("fail") } } func u64run() { var a, b uint64 for i := 0; i < Count; i++ { a = u64rand() b = a % 1 u64test(a, b, 1) b = a % 2 u64test(a, b, 2) b = a % 3 u64test(a, b, 3) b = a % 4 u64test(a, b, 4) b = a % 5 u64test(a, b, 5) b = a % 6 u64test(a, b, 6) b = a % 7 u64test(a, b, 7) b = a % 8 u64test(a, b, 8) b = a % 10 u64test(a, b, 10) b = a % 16 u64test(a, b, 16) b = a % 20 u64test(a, b, 20) b = a % 32 u64test(a, b, 32) b = a % 60 u64test(a, b, 60) b = a % 64 u64test(a, b, 64) b = a % 128 u64test(a, b, 128) b = a % 256 u64test(a, b, 256) b = a % 16384 u64test(a, b, 16384) } } func i32rand() int32 { for { a := int32(rand.Uint32()) a >>= uint(rand.Intn(32)) if -a != a { return a } } return 0 // impossible } func i32test(a, b, c int32) { d := a % c if d != b { println("i32", a, b, c, d) panic("fail") } } func i32run() { var a, b int32 for i := 0; i < Count; i++ { a = i32rand() b = a % 1 i32test(a, b, 1) b = a % 2 i32test(a, b, 2) b = a % 3 i32test(a, b, 3) b = a % 4 i32test(a, b, 4) b = a % 5 i32test(a, b, 5) b = a % 6 i32test(a, b, 6) b = a % 7 i32test(a, b, 7) b = a % 8 i32test(a, b, 8) b = a % 10 i32test(a, b, 10) b = a % 16 i32test(a, b, 16) b = a % 20 i32test(a, b, 20) b = a % 32 i32test(a, b, 32) b = a % 60 i32test(a, b, 60) b = a % 64 i32test(a, b, 64) b = a % 128 i32test(a, b, 128) b = a % 256 i32test(a, b, 256) b = a % 16384 i32test(a, b, 16384) b = a % -1 i32test(a, b, -1) b = a % -2 i32test(a, b, -2) b = a % -3 i32test(a, b, -3) b = a % -4 i32test(a, b, -4) b = a % -5 i32test(a, b, -5) b = a % -6 i32test(a, b, -6) b = a % -7 i32test(a, b, -7) b = a % -8 i32test(a, b, -8) b = a % -10 i32test(a, b, -10) b = a % -16 i32test(a, b, -16) b = a % -20 i32test(a, b, -20) b = a % -32 i32test(a, b, -32) b = a % -60 i32test(a, b, -60) b = a % -64 i32test(a, b, -64) b = a % -128 i32test(a, b, -128) b = a % -256 i32test(a, b, -256) } } func u32rand() uint32 { a := uint32(rand.Uint32()) a >>= uint(rand.Intn(32)) return a } func u32test(a, b, c uint32) { d := a % c if d != b { println("u32", a, b, c, d) panic("fail") } } func u32run() { var a, b uint32 for i := 0; i < Count; i++ { a = u32rand() b = a % 1 u32test(a, b, 1) b = a % 2 u32test(a, b, 2) b = a % 3 u32test(a, b, 3) b = a % 4 u32test(a, b, 4) b = a % 5 u32test(a, b, 5) b = a % 6 u32test(a, b, 6) b = a % 7 u32test(a, b, 7) b = a % 8 u32test(a, b, 8) b = a % 10 u32test(a, b, 10) b = a % 16 u32test(a, b, 16) b = a % 20 u32test(a, b, 20) b = a % 32 u32test(a, b, 32) b = a % 60 u32test(a, b, 60) b = a % 64 u32test(a, b, 64) b = a % 128 u32test(a, b, 128) b = a % 256 u32test(a, b, 256) b = a % 16384 u32test(a, b, 16384) } } func i16rand() int16 { for { a := int16(rand.Uint32()) a >>= uint(rand.Intn(16)) if -a != a { return a } } return 0 // impossible } func i16test(a, b, c int16) { d := a % c if d != b { println("i16", a, b, c, d) panic("fail") } } func i16run() { var a, b int16 for i := 0; i < Count; i++ { a = i16rand() b = a % 1 i16test(a, b, 1) b = a % 2 i16test(a, b, 2) b = a % 3 i16test(a, b, 3) b = a % 4 i16test(a, b, 4) b = a % 5 i16test(a, b, 5) b = a % 6 i16test(a, b, 6) b = a % 7 i16test(a, b, 7) b = a % 8 i16test(a, b, 8) b = a % 10 i16test(a, b, 10) b = a % 16 i16test(a, b, 16) b = a % 20 i16test(a, b, 20) b = a % 32 i16test(a, b, 32) b = a % 60 i16test(a, b, 60) b = a % 64 i16test(a, b, 64) b = a % 128 i16test(a, b, 128) b = a % 256 i16test(a, b, 256) b = a % 16384 i16test(a, b, 16384) b = a % -1 i16test(a, b, -1) b = a % -2 i16test(a, b, -2) b = a % -3 i16test(a, b, -3) b = a % -4 i16test(a, b, -4) b = a % -5 i16test(a, b, -5) b = a % -6 i16test(a, b, -6) b = a % -7 i16test(a, b, -7) b = a % -8 i16test(a, b, -8) b = a % -10 i16test(a, b, -10) b = a % -16 i16test(a, b, -16) b = a % -20 i16test(a, b, -20) b = a % -32 i16test(a, b, -32) b = a % -60 i16test(a, b, -60) b = a % -64 i16test(a, b, -64) b = a % -128 i16test(a, b, -128) b = a % -256 i16test(a, b, -256) b = a % -16384 i16test(a, b, -16384) } } func u16rand() uint16 { a := uint16(rand.Uint32()) a >>= uint(rand.Intn(16)) return a } func u16test(a, b, c uint16) { d := a % c if d != b { println("u16", a, b, c, d) panic("fail") } } func u16run() { var a, b uint16 for i := 0; i < Count; i++ { a = u16rand() b = a % 1 u16test(a, b, 1) b = a % 2 u16test(a, b, 2) b = a % 3 u16test(a, b, 3) b = a % 4 u16test(a, b, 4) b = a % 5 u16test(a, b, 5) b = a % 6 u16test(a, b, 6) b = a % 7 u16test(a, b, 7) b = a % 8 u16test(a, b, 8) b = a % 10 u16test(a, b, 10) b = a % 16 u16test(a, b, 16) b = a % 20 u16test(a, b, 20) b = a % 32 u16test(a, b, 32) b = a % 60 u16test(a, b, 60) b = a % 64 u16test(a, b, 64) b = a % 128 u16test(a, b, 128) b = a % 256 u16test(a, b, 256) b = a % 16384 u16test(a, b, 16384) } } func i8rand() int8 { for { a := int8(rand.Uint32()) a >>= uint(rand.Intn(8)) if -a != a { return a } } return 0 // impossible } func i8test(a, b, c int8) { d := a % c if d != b { println("i8", a, b, c, d) panic("fail") } } func i8run() { var a, b int8 for i := 0; i < Count; i++ { a = i8rand() b = a % 1 i8test(a, b, 1) b = a % 2 i8test(a, b, 2) b = a % 3 i8test(a, b, 3) b = a % 4 i8test(a, b, 4) b = a % 5 i8test(a, b, 5) b = a % 6 i8test(a, b, 6) b = a % 7 i8test(a, b, 7) b = a % 8 i8test(a, b, 8) b = a % 10 i8test(a, b, 10) b = a % 8 i8test(a, b, 8) b = a % 20 i8test(a, b, 20) b = a % 32 i8test(a, b, 32) b = a % 60 i8test(a, b, 60) b = a % 64 i8test(a, b, 64) b = a % 127 i8test(a, b, 127) b = a % -1 i8test(a, b, -1) b = a % -2 i8test(a, b, -2) b = a % -3 i8test(a, b, -3) b = a % -4 i8test(a, b, -4) b = a % -5 i8test(a, b, -5) b = a % -6 i8test(a, b, -6) b = a % -7 i8test(a, b, -7) b = a % -8 i8test(a, b, -8) b = a % -10 i8test(a, b, -10) b = a % -8 i8test(a, b, -8) b = a % -20 i8test(a, b, -20) b = a % -32 i8test(a, b, -32) b = a % -60 i8test(a, b, -60) b = a % -64 i8test(a, b, -64) b = a % -128 i8test(a, b, -128) b = a % -101 i8test(a, b, -101) } } func u8rand() uint8 { a := uint8(rand.Uint32()) a >>= uint(rand.Intn(8)) return a } func u8test(a, b, c uint8) { d := a % c if d != b { println("u8", a, b, c, d) panic("fail") } } func u8run() { var a, b uint8 for i := 0; i < Count; i++ { a = u8rand() b = a % 1 u8test(a, b, 1) b = a % 2 u8test(a, b, 2) b = a % 3 u8test(a, b, 3) b = a % 4 u8test(a, b, 4) b = a % 5 u8test(a, b, 5) b = a % 6 u8test(a, b, 6) b = a % 7 u8test(a, b, 7) b = a % 8 u8test(a, b, 8) b = a % 10 u8test(a, b, 10) b = a % 8 u8test(a, b, 8) b = a % 20 u8test(a, b, 20) b = a % 32 u8test(a, b, 32) b = a % 60 u8test(a, b, 60) b = a % 64 u8test(a, b, 64) b = a % 127 u8test(a, b, 127) } } func main() { xtest() i64run() u64run() i32run() u32run() i16run() u16run() i8run() u8run() } func xtest() { }	9.24 KB	2024-02-02 18:09
📄 ptrfun.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test method invocation with pointer receivers and function-valued fields. package main type C struct { a int; x func(p C)int; } func (this C) f()int { return this.a; } func main() { var v int; var c C; c = new(C); c.a = 6; c.x = g; v = g(c); if v != 6 { panic(v); } v = c.x(c); if v != 6 { panic(v); } v = c.f(); if v != 6 { panic(v); } } func g(p C)int { var v int; v = p.a; if v != 6 { panic(v); } return p.a; }	617 B	2024-02-02 18:09
📄 ptrvar.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test pointers and the . (selector) operator on structs. package main type x2 struct { a,b,c int; d int; }; var g1 x2; var g2 struct { a,b,c int; d x2; }; func main() { var x int; var s1 x2; var s2 struct { a,b,c int; d x2; }; s1 = &g1; s2 = &g2; s1.a = 1; s1.b = 2; s1.c = 3; s1.d = 5; s2.a = 7; s2.b = 11; s2.c = 13; s2.d.a = 17; s2.d.b = 19; s2.d.c = 23; s2.d.d = 20; if(s2.d.c != 23) { panic(1); } if(g2.d.c != 23) { panic(2); } x = s1.a + s1.b + s1.c + s1.d + s2.a + s2.b + s2.c + s2.d.a + s2.d.b + s2.d.c + s2.d.d; if(x != 121) { panic(x); } }	772 B	2024-02-02 18:09
📄 range.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test 'for range' on arrays, slices, and maps. package main const size = 16 var a [size]byte var p []byte var m map[int]byte func f(k int) byte { return byte(k * 10007 % size) } func init() { p = make([]byte, size) m = make(map[int]byte) for k := 0; k < size; k++ { v := f(k) a[k] = v p[k] = v m[k] = v } } func main() { var i int /* * key only / i = 0 for k := range a { v := a[k] if v != f(k) { println("key array range", k, v, a[k]) panic("fail") } i++ } if i != size { println("key array size", i) panic("fail") } i = 0 for k := range p { v := p[k] if v != f(k) { println("key pointer range", k, v, p[k]) panic("fail") } i++ } if i != size { println("key pointer size", i) panic("fail") } i = 0 for k := range m { v := m[k] if v != f(k) { println("key map range", k, v, m[k]) panic("fail") } i++ } if i != size { println("key map size", i) panic("fail") } / * key,value */ i = 0 for k, v := range a { if v != f(k) { println("key:value array range", k, v, a[k]) panic("fail") } i++ } if i != size { println("key:value array size", i) panic("fail") } i = 0 for k, v := range p { if v != f(k) { println("key:value pointer range", k, v, p[k]) panic("fail") } i++ } if i != size { println("key:value pointer size", i) panic("fail") } i = 0 for k, v := range m { if v != f(k) { println("key:value map range", k, v, m[k]) panic("fail") } i++ } if i != size { println("key:value map size", i) panic("fail") } }	1.71 KB	2024-02-02 18:09
📄 rob1.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test general operation using a list implementation. package main type Item interface { Print() string } type ListItem struct { item Item next ListItem } type List struct { head ListItem } func (list List) Init() { list.head = nil } func (list List) Insert(i Item) { item := new(ListItem) item.item = i item.next = list.head list.head = item } func (list List) Print() string { r := "" i := list.head for i != nil { r += i.item.Print() i = i.next } return r } // Something to put in a list type Integer struct { val int } func (this Integer) Init(i int) Integer { this.val = i return this } func (this Integer) Print() string { return string(this.val + '0') } func main() { list := new(List) list.Init() for i := 0; i < 10; i = i + 1 { integer := new(Integer) integer.Init(i) list.Insert(integer) } r := list.Print() if r != "9876543210" { panic(r) } }	1.05 KB	2024-02-02 18:09
📄 rob2.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test general operation using s-list. // First Go program ever run (although not in this exact form). package main import "fmt" const nilchar = 0 type Atom struct { str string integer int next Slist / in hash bucket / } type List struct { car Slist cdr Slist } type Slist struct { isatom bool isstring bool //union { atom Atom list List //} u; } func (this Slist) Car() Slist { return this.list.car } func (this Slist) Cdr() Slist { return this.list.cdr } func (this Slist) String() string { return this.atom.str } func (this Slist) Integer() int { return this.atom.integer } func (slist Slist) Free() { if slist == nil { return } if slist.isatom { // free(slist.String()); } else { slist.Car().Free() slist.Cdr().Free() } // free(slist); } //Slist* atom(byte s, int i); var token int var peekc int = -1 var lineno int32 = 1 var input string var inputindex int = 0 var tokenbuf [100]byte var tokenlen int = 0 const EOF int = -1 func main() { var list Slist OpenFile() for { list = Parse() if list == nil { break } r := list.Print() list.Free() if r != "(defn foo (add 12 34))" { panic(r) } break } } func (slist Slist) PrintOne(doparen bool) string { if slist == nil { return "" } var r string if slist.isatom { if slist.isstring { r = slist.String() } else { r = fmt.Sprintf("%v", slist.Integer()) } } else { if doparen { r += "(" } r += slist.Car().PrintOne(true) if slist.Cdr() != nil { r += " " r += slist.Cdr().PrintOne(false) } if doparen { r += ")" } } return r } func (slist Slist) Print() string { return slist.PrintOne(true) } func Get() int { var c int if peekc >= 0 { c = peekc peekc = -1 } else { c = int(input[inputindex]) inputindex++ if c == '\n' { lineno = lineno + 1 } if c == nilchar { inputindex = inputindex - 1 c = EOF } } return c } func WhiteSpace(c int) bool { return c == ' ' \|\| c == '\t' \|\| c == '\r' \|\| c == '\n' } func NextToken() { var i, c int tokenbuf[0] = nilchar // clear previous token c = Get() for WhiteSpace(c) { c = Get() } switch c { case EOF: token = EOF case '(', ')': token = c break default: for i = 0; i < 100-1; { // sizeof tokenbuf - 1 tokenbuf[i] = byte(c) i = i + 1 c = Get() if c == EOF { break } if WhiteSpace(c) \|\| c == ')' { peekc = c break } } if i >= 100-1 { // sizeof tokenbuf - 1 panic("atom too long\n") } tokenlen = i tokenbuf[i] = nilchar if '0' <= tokenbuf[0] && tokenbuf[0] <= '9' { token = '0' } else { token = 'A' } } } func Expect(c int) { if token != c { print("parse error: expected ", c, "\n") panic("parse") } NextToken() } // Parse a non-parenthesized list up to a closing paren or EOF func ParseList() Slist { var slist, retval Slist slist = new(Slist) slist.list.car = nil slist.list.cdr = nil slist.isatom = false slist.isstring = false retval = slist for { slist.list.car = Parse() if token == ')' \|\| token == EOF { // empty cdr break } slist.list.cdr = new(Slist) slist = slist.list.cdr } return retval } func atom(i int) Slist { // BUG: uses tokenbuf; should take argument) var slist Slist slist = new(Slist) if token == '0' { slist.atom.integer = i slist.isstring = false } else { slist.atom.str = string(tokenbuf[0:tokenlen]) slist.isstring = true } slist.isatom = true return slist } func atoi() int { // BUG: uses tokenbuf; should take argument) var v int = 0 for i := 0; i < tokenlen && '0' <= tokenbuf[i] && tokenbuf[i] <= '9'; i = i + 1 { v = 10v + int(tokenbuf[i]-'0') } return v } func Parse() Slist { var slist *Slist if token == EOF \|\| token == ')' { return nil } if token == '(' { NextToken() slist = ParseList() Expect(')') return slist } else { // Atom switch token { case EOF: return nil case '0': slist = atom(atoi()) case '"', 'A': slist = atom(0) default: slist = nil print("unknown token: ", token, "\n") } NextToken() return slist } return nil } func OpenFile() { input = "(defn foo (add 12 34))\n\x00" inputindex = 0 peekc = -1 // BUG NextToken() }	4.3 KB	2024-02-02 18:09
📄 robfor.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test for loops of many forms. package main func assertequal(is, shouldbe int, msg string) { if is != shouldbe { print("assertion fail" + msg + "\n"); panic(1); } } func main() { var i, sum int; i = 0; for { i = i + 1; if i > 5 { break; } } assertequal(i, 6, "break"); sum = 0; for i := 0; i <= 10; i++ { sum = sum + i; } assertequal(sum, 55, "all three"); sum = 0; for i := 0; i <= 10; { sum = sum + i; i++; } assertequal(sum, 55, "only two"); sum = 0; for sum < 100 { sum = sum + 9; } assertequal(sum, 99 + 9, "only one"); sum = 0; for i := 0; i <= 10; i++ { if i % 2 == 0 { continue; } sum = sum + i; } assertequal(sum, 1+3+5+7+9, "continue"); }	881 B	2024-02-02 18:09
📄 robfunc.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test functions of many signatures. package main func assertequal(is, shouldbe int, msg string) { if is != shouldbe { print("assertion fail" + msg + "\n") panic(1) } } func f1() { } func f2(a int) { } func f3(a, b int) int { return a + b } func f4(a, b int, c float64) int { return (a+b)/2 + int(c) } func f5(a int) int { return 5 } func f6(a int) (r int) { return 6 } func f7(a int) (x int, y float64) { return 7, 7.0 } func f8(a int) (x int, y float64) { return 8, 8.0 } type T struct { x, y int } func (t T) m10(a int, b float64) int { return (t.x + a) (t.y + int(b)) } func f9(a int) (in int, fl float64) { i := 9 f := float64(9) return i, f } func main() { f1() f2(1) r3 := f3(1, 2) assertequal(r3, 3, "3") r4 := f4(0, 2, 3.0) assertequal(r4, 4, "4") r5 := f5(1) assertequal(r5, 5, "5") r6 := f6(1) assertequal(r6, 6, "6") var r7 int var s7 float64 r7, s7 = f7(1) assertequal(r7, 7, "r7") assertequal(int(s7), 7, "s7") var r8 int var s8 float64 r8, s8 = f8(1) assertequal(r8, 8, "r8") assertequal(int(s8), 8, "s8") var r9 int var s9 float64 r9, s9 = f9(1) assertequal(r9, 9, "r9") assertequal(int(s9), 9, "s9") var t *T = new(T) t.x = 1 t.y = 2 r10 := t.m10(1, 3.0) assertequal(r10, 10, "10") }	1.4 KB	2024-02-02 18:09
📄 shift.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test shift. package main var ians [18]int; var uans [18]uint; var pass string; func testi(i int, t1,t2,t3 int) { n := ((t13) + t2)2 + t3; if i != ians[n] { print("itest ", t1,t2,t3,pass, " is ", i, " sb ", ians[n], "\n"); } } func index(t1,t2,t3 int) int { return ((t13) + t2)2 + t3; } func testu(u uint, t1,t2,t3 int) { n := index(t1,t2,t3); if u != uans[n] { print("utest ", t1,t2,t3,pass, " is ", u, " sb ", uans[n], "\n"); } } func main() { var i int; var u,c uint; /* * test constant evaluations / pass = "con"; // constant part testi( int(1234) << 0, 0,0,0); testi( int(1234) >> 0, 0,0,1); testi( int(1234) << 5, 0,1,0); testi( int(1234) >> 5, 0,1,1); testi(int(-1234) << 0, 1,0,0); testi(int(-1234) >> 0, 1,0,1); testi(int(-1234) << 5, 1,1,0); testi(int(-1234) >> 5, 1,1,1); testu(uint(5678) << 0, 2,0,0); testu(uint(5678) >> 0, 2,0,1); testu(uint(5678) << 5, 2,1,0); testu(uint(5678) >> 5, 2,1,1); / * test variable evaluations / pass = "var"; // variable part for t1:=0; t1<3; t1++ { // +int, -int, uint for t2:=0; t2<3; t2++ { // 0, +small, +large for t3:=0; t3<2; t3++ { // <<, >> switch t1 { case 0: i = 1234; case 1: i = -1234; case 2: u = 5678; } switch t2 { case 0: c = 0; case 1: c = 5; case 2: c = 1025; } switch t3 { case 0: i <<= c; u <<= c; case 1: i >>= c; u >>= c; } switch t1 { case 0: testi(i,t1,t2,t3); case 1: testi(i,t1,t2,t3); case 2: testu(u,t1,t2,t3); } } } } } func init() { / * set the 'correct' answer */ ians[index(0,0,0)] = 1234; ians[index(0,0,1)] = 1234; ians[index(0,1,0)] = 39488; ians[index(0,1,1)] = 38; ians[index(0,2,0)] = 0; ians[index(0,2,1)] = 0; ians[index(1,0,0)] = -1234; ians[index(1,0,1)] = -1234; ians[index(1,1,0)] = -39488; ians[index(1,1,1)] = -39; ians[index(1,2,0)] = 0; ians[index(1,2,1)] = -1; uans[index(2,0,0)] = 5678; uans[index(2,0,1)] = 5678; uans[index(2,1,0)] = 181696; uans[index(2,1,1)] = 177; uans[index(2,2,0)] = 0; uans[index(2,2,1)] = 0; }	2.26 KB	2024-02-02 18:09
📄 simparray.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test simple operations on arrays. package main var b[10] float32; func main() { var a[10] float32; for i:=int16(5); i<10; i=i+1 { a[i] = float32(i); } s1 := float32(0); for i:=5; i<10; i=i+1 { s1 = s1 + a[i]; } if s1 != 35 { panic(s1); } for i:=int16(5); i<10; i=i+1 { b[i] = float32(i); } s2 := float32(0); for i:=5; i<10; i=i+1 { s2 = s2 + b[i]; } if s2 != 35 { panic(s2); } b := new([100]int); for i:=0; i<100; i=i+1 { b[i] = i; } s3 := 0; for i:=0; i<100; i=i+1 { s3 = s3+b[i]; } if s3 != 4950 { panic(s3); } }	730 B	2024-02-02 18:09
📄 simpbool.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test basic operations on bool. package main type s struct { a bool; b bool; } func main() { var a,b bool; a = true; b = false; if !a { panic(1); } if b { panic(2); } if !!!a { panic(3); } if !!b { panic(4); } a = !b; if !a { panic(5); } if !!!a { panic(6); } var x s; x = new(s); x.a = true; x.b = false; if !x.a { panic(7); } if x.b { panic(8); } if !!!x.a { panic(9); } if !!x.b { panic(10); } x.a = !x.b; if !x.a { panic(11); } if !!!x.a { panic(12); } / * test && / a = true; b = true; if !(a && b) { panic(21); } if a && !b { panic(22); } if !a && b { panic(23); } if !a && !b { panic(24); } a = false; b = true; if !(!a && b) { panic(31); } if !a && !b { panic(32); } if a && b { panic(33); } if a && !b { panic(34); } a = true; b = false; if !(a && !b) { panic(41); } if a && b { panic(41); } if !a && !b { panic(41); } if !a && b { panic(44); } a = false; b = false; if !(!a && !b) { panic(51); } if !a && b { panic(52); } if a && !b { panic(53); } if a && b { panic(54); } / * test \|\| */ a = true; b = true; if !(a \|\| b) { panic(61); } if !(a \|\| !b) { panic(62); } if !(!a \|\| b) { panic(63); } if !a \|\| !b { panic(64); } a = false; b = true; if !(!a \|\| b) { panic(71); } if !(!a \|\| !b) { panic(72); } if !(a \|\| b) { panic(73); } if a \|\| !b { panic(74); } a = true; b = false; if !(a \|\| !b) { panic(81); } if !(a \|\| b) { panic(82); } if !(!a \|\| !b) { panic(83); } if !a \|\| b { panic(84); } a = false; b = false; if !(!a \|\| !b) { panic(91); } if !(!a \|\| b) { panic(92); } if !(a \|\| !b) { panic(93); } if a \|\| b { panic(94); } }	1.77 KB	2024-02-02 18:09
📄 simpconv.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test simple arithmetic conversion. package main type vlong int64 type short int16 func main() { s1 := vlong(0) for i := short(0); i < 10; i = i + 1 { s1 = s1 + vlong(i) } if s1 != 45 { panic(s1) } s2 := float64(0) for i := 0; i < 10; i = i + 1 { s2 = s2 + float64(i) } if s2 != 45 { panic(s2) } }	490 B	2024-02-02 18:09
📄 simpfun.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test simple functions. package main func main() { var x int; x = fun(10,20,30); if x != 60 { panic(x); } } func fun(ia,ib,ic int)int { var o int; o = ia+ib+ic; if o != 60 { panic(o); } return o; }	380 B	2024-02-02 18:09
📄 simpswitch.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test simple switch. package main func main() { r := "" a := 3 for i := 0; i < 10; i = i + 1 { switch i { case 5: r += "five" case a, 7: r += "a" default: r += string(i + '0') } r += "out" + string(i+'0') } if r != "0out01out12out2aout34out4fiveout56out6aout78out89out9" { panic(r) } }	487 B	2024-02-02 18:09
📄 simpvar.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test scoping of variables. package main var x,y int; func main() { x = 15; y = 20; { var x int; x = 25; y = 25; _ = x; } x = x+y; if(x != 40) { panic(x); } }	348 B	2024-02-02 18:09
📄 slicearray.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test basic operations of slices and arrays. package main var bx [10]byte var by []byte var fx [10]float64 var fy []float64 var lb, hb int var t int func main() { lb = 0 hb = 10 by = bx[0:] tstb() lb = 0 hb = 10 fy = fx[0:] tstf() // width 1 (byte) lb = 0 hb = 10 by = bx[lb:hb] tstb() by = bx[lb:10] tstb() by = bx[lb:] tstb() by = bx[:hb] tstb() by = bx[0:hb] tstb() by = bx[0:10] tstb() by = bx[0:] tstb() by = bx[:10] tstb() by = bx[:] tstb() lb = 2 hb = 10 by = bx[lb:hb] tstb() by = bx[lb:10] tstb() by = bx[lb:] tstb() by = bx[2:hb] tstb() by = bx[2:10] tstb() by = bx[2:] tstb() lb = 0 hb = 8 by = bx[lb:hb] tstb() by = bx[lb:8] tstb() by = bx[0:hb] tstb() by = bx[0:8] tstb() by = bx[:8] tstb() by = bx[:hb] tstb() lb = 2 hb = 8 by = bx[lb:hb] tstb() by = bx[lb:8] tstb() by = bx[2:hb] tstb() by = bx[2:8] tstb() // width 8 (float64) lb = 0 hb = 10 fy = fx[lb:hb] tstf() fy = fx[lb:10] tstf() fy = fx[lb:] tstf() fy = fx[:hb] tstf() fy = fx[0:hb] tstf() fy = fx[0:10] tstf() fy = fx[0:] tstf() fy = fx[:10] tstf() fy = fx[:] tstf() lb = 2 hb = 10 fy = fx[lb:hb] tstf() fy = fx[lb:10] tstf() fy = fx[lb:] tstf() fy = fx[2:hb] tstf() fy = fx[2:10] tstf() fy = fx[2:] tstf() lb = 0 hb = 8 fy = fx[lb:hb] tstf() fy = fx[lb:8] tstf() fy = fx[:hb] tstf() fy = fx[0:hb] tstf() fy = fx[0:8] tstf() fy = fx[:8] tstf() lb = 2 hb = 8 fy = fx[lb:hb] tstf() fy = fx[lb:8] tstf() fy = fx[2:hb] tstf() fy = fx[2:8] tstf() } func tstb() { t++ if len(by) != hb-lb { println("t=", t, "lb=", lb, "hb=", hb, "len=", len(by), "hb-lb=", hb-lb) panic("fail") } if cap(by) != len(bx)-lb { println("t=", t, "lb=", lb, "hb=", hb, "cap=", cap(by), "len(bx)-lb=", len(bx)-lb) panic("fail") } for i := lb; i < hb; i++ { if bx[i] != by[i-lb] { println("t=", t, "lb=", lb, "hb=", hb, "bx[", i, "]=", bx[i], "by[", i-lb, "]=", by[i-lb]) panic("fail") } } by = nil } func tstf() { t++ if len(fy) != hb-lb { println("t=", t, "lb=", lb, "hb=", hb, "len=", len(fy), "hb-lb=", hb-lb) panic("fail") } if cap(fy) != len(fx)-lb { println("t=", t, "lb=", lb, "hb=", hb, "cap=", cap(fy), "len(fx)-lb=", len(fx)-lb) panic("fail") } for i := lb; i < hb; i++ { if fx[i] != fy[i-lb] { println("t=", t, "lb=", lb, "hb=", hb, "fx[", i, "]=", fx[i], "fy[", i-lb, "]=", fy[i-lb]) panic("fail") } } fy = nil } func init() { for i := 0; i < len(bx); i++ { bx[i] = byte(i + 20) } by = nil for i := 0; i < len(fx); i++ { fx[i] = float64(i + 20) } fy = nil }	2.75 KB	2024-02-02 18:09
📄 sliceslice.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test slicing and re-slicing. package main var bx []byte var by []byte var fx []float64 var fy []float64 var lb, hb int var t int func main() { // width 1 (byte) lb = 0 hb = 10 by = bx[lb:hb] tstb() by = bx[lb:10] tstb() by = bx[lb:] tstb() by = bx[:hb] tstb() by = bx[0:hb] tstb() by = bx[0:10] tstb() by = bx[0:] tstb() by = bx[:10] tstb() by = bx[:] tstb() lb = 2 hb = 10 by = bx[lb:hb] tstb() by = bx[lb:10] tstb() by = bx[lb:] tstb() by = bx[2:hb] tstb() by = bx[2:10] tstb() by = bx[2:] tstb() lb = 0 hb = 8 by = bx[lb:hb] tstb() by = bx[lb:8] tstb() by = bx[0:hb] tstb() by = bx[0:8] tstb() by = bx[:8] tstb() by = bx[:hb] tstb() lb = 2 hb = 8 by = bx[lb:hb] tstb() by = bx[lb:8] tstb() by = bx[2:hb] tstb() by = bx[2:8] tstb() // width 4 (float64) lb = 0 hb = 10 fy = fx[lb:hb] tstf() fy = fx[lb:10] tstf() fy = fx[lb:] tstf() fy = fx[:hb] tstf() fy = fx[0:hb] tstf() fy = fx[0:10] tstf() fy = fx[0:] tstf() fy = fx[:10] tstf() fy = fx[:] tstf() lb = 2 hb = 10 fy = fx[lb:hb] tstf() fy = fx[lb:10] tstf() fy = fx[lb:] tstf() fy = fx[2:hb] tstf() fy = fx[2:10] tstf() fy = fx[2:] tstf() lb = 0 hb = 8 fy = fx[lb:hb] tstf() fy = fx[lb:8] tstf() fy = fx[:hb] tstf() fy = fx[0:hb] tstf() fy = fx[0:8] tstf() fy = fx[:8] tstf() lb = 2 hb = 8 fy = fx[lb:hb] tstf() fy = fx[lb:8] tstf() fy = fx[2:hb] tstf() fy = fx[2:8] tstf() } func tstb() { t++ if len(by) != hb-lb { println("t=", t, "lb=", lb, "hb=", hb, "len=", len(by), "hb-lb=", hb-lb) panic("fail") } if cap(by) != len(bx)-lb { println("t=", t, "lb=", lb, "hb=", hb, "cap=", cap(by), "len(bx)-lb=", len(bx)-lb) panic("fail") } for i := lb; i < hb; i++ { if bx[i] != by[i-lb] { println("t=", t, "lb=", lb, "hb=", hb, "bx[", i, "]=", bx[i], "by[", i-lb, "]=", by[i-lb]) panic("fail") } } by = nil } func tstf() { t++ if len(fy) != hb-lb { println("t=", t, "lb=", lb, "hb=", hb, "len=", len(fy), "hb-lb=", hb-lb) panic("fail") } if cap(fy) != len(fx)-lb { println("t=", t, "lb=", lb, "hb=", hb, "cap=", cap(fy), "len(fx)-lb=", len(fx)-lb) panic("fail") } for i := lb; i < hb; i++ { if fx[i] != fy[i-lb] { println("t=", t, "lb=", lb, "hb=", hb, "fx[", i, "]=", fx[i], "fy[", i-lb, "]=", fy[i-lb]) panic("fail") } } fy = nil } func init() { bx = make([]byte, 10) for i := 0; i < len(bx); i++ { bx[i] = byte(i + 20) } by = nil fx = make([]float64, 10) for i := 0; i < len(fx); i++ { fx[i] = float64(i + 20) } fy = nil }	2.7 KB	2024-02-02 18:09
📄 string.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test string operations including printing. package main func main() { var c string a := `abc` b := `xyz` /* print a literal / print(`abc`) / print a variable / print(b, "-") / catenate literals / print(`abc`+`xyz`, "-") / catenate variables / print(a+b, "-") / compare literals / if `abc` == `xyz` \|\| `abc` != "abc" \|\| `abc` > `xyz` { panic("compare literals") } / compare variables / if a == b \|\| a != a \|\| a > b { panic("compare variables") } / cat / c = a + b print(c, "-") / catequal / c = a c += b print(c, "-") / clumsy evaluation / c = b c = a + c print(c, "-") / len / if len(c) != 6 { print("len ", len(c)) panic("fail") } / index strings / for i := 0; i < len(c); i = i + 1 { if c[i] != (a + b)[i] { print("index ", i, " ", c[i], " ", (a + b)[i]) panic("fail") } } / slice strings / print(c[0:3], c[3:]) print("\n") / create string with integer constant / c = string('x') if c != "x" { panic("create int " + c) } / create string with integer variable / v := 'x' c = string(v) if c != "x" { panic("create int " + c) } / create string with byte array / var z1 [3]byte z1[0] = 'a' z1[1] = 'b' z1[2] = 'c' c = string(z1[0:]) if c != "abc" { panic("create byte array " + c) } / create string with int array / var z2 [3]rune z2[0] = 'a' z2[1] = '\u1234' z2[2] = 'c' c = string(z2[0:]) if c != "a\u1234c" { panic("create int array " + c) } / create string with byte array pointer */ z3 := new([3]byte) z3[0] = 'a' z3[1] = 'b' z3[2] = 'c' c = string(z3[0:]) if c != "abc" { panic("create array pointer " + c) } }	1.79 KB	2024-02-02 18:09
📄 string.out abcxyz-abcxyz-abcxyz-abcxyz-abcxyz-abcxyz-abcxyz	49 B	2024-02-02 18:09
📄 strvar.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test struct-valued variables (not pointers). package main type x2 struct { a,b,c int; d int; }; var g1 x2; var g2 struct { a,b,c int; d x2; }; func main() { var x int; var s1 x2; var s2 struct { a,b,c int; d x2; }; var s3 struct { a,b,c int; d x2; }; s1 = &g1; s2 = &g2; s1.a = 1; s1.b = 2; s1.c = 3; s1.d = 5; if(s1.c != 3) { panic(s1.c); } if(g1.c != 3) { panic(g1.c); } s2.a = 7; s2.b = 11; s2.c = 13; s2.d.a = 17; s2.d.b = 19; s2.d.c = 23; s2.d.d = 29; if(s2.d.c != 23) { panic(s2.d.c); } if(g2.d.c != 23) { panic(g2.d.c); } x = s1.a + s1.b + s1.c + s1.d + s2.a + s2.b + s2.c + s2.d.a + s2.d.b + s2.d.c + s2.d.d; if(x != 130) { panic(x); } // test an automatic struct s3.a = 7; s3.b = 11; s3.c = 13; s3.d.a = 17; s3.d.b = 19; s3.d.c = 23; s3.d.d = 29; if(s3.d.c != 23) { panic(s3.d.c); } x = s3.a + s3.b + s3.c + s3.d.a + s3.d.b + s3.d.c + s3.d.d; if(x != 119) { panic(x); } }	1.11 KB	2024-02-02 18:09

Edit File:

Terminal