func testCallBy() { var a struct { b int } var x [10]int var y []int = make([]int, 1) var z int testCallByValue(a, x, y, z) TEQ(tardisgolib.CPos(), a.b, 0) TEQ(tardisgolib.CPos(), x[0], 0) TEQ(tardisgolib.CPos(), y[0], 44) TEQ(tardisgolib.CPos(), z, 0) testCallByReference(&a, &x, y, &z) TEQ(tardisgolib.CPos(), a.b, 46) TEQ(tardisgolib.CPos(), x[0], 47) TEQ(tardisgolib.CPos(), y[0], 48) TEQ(tardisgolib.CPos(), z, 49) var xx [10]float64 for i := range x { xx[i] = float64(i * i) testTweakFloatByReference(&xx[i]) TEQfloat(tardisgolib.CPos(), xx[i], float64(i), 0.1) } }
func testMap() { // and map-like constucts // vowels[ch] is true if ch is a vowel vowels := [128]bool{'a': true, 'e': true, 'i': true, 'o': true, 'u': true, 'y': true} for k, v := range vowels { switch k { case 'a', 'e', 'i', 'o', 'u', 'y': TEQ(tardisgolib.CPos(), true, v) default: TEQ(tardisgolib.CPos(), false, v) } } filter := [10]float64{-1, 4: -0.1, -0.1, 9: -1} TEQfloat(tardisgolib.CPos(), filter[5], -0.1, 0.01) // frequencies in Hz for equal-tempered scale (A4 = 440Hz) noteFrequency := map[string]float64{ "C0": 16.35, "D0": 18.35, "E0": 20.60, "F0": 21.83, "G0": 24.50, "A0": 27.50, "B0": 30.87, } noteFrequency["Test"] = 42.42 TEQ(tardisgolib.CPos(), len(noteFrequency), 8) for k, v := range noteFrequency { r := 0.0 switch k { case "C0": r = 16.35 case "D0": r = 18.35 case "E0": r = 20.60 case "F0": r = 21.83 case "G0": r = 24.50 case "A0": r = 27.50 case "B0": r = 30.87 case "Test": r = 42.42 default: r = -1 } if !TEQfloat(tardisgolib.CPos()+" Value itterator in map", v, r, 0.01) { break } } x, isok := noteFrequency["Test"] TEQfloat(tardisgolib.CPos(), 42.42, x, 0.01) TEQ(tardisgolib.CPos(), true, isok) _, notok := noteFrequency["notHere"] TEQ(tardisgolib.CPos(), false, notok) delete(noteFrequency, "Test") _, isok = noteFrequency["Test"] TEQ(tardisgolib.CPos(), false, isok) }
func testClosure() { // example from the go tour pos, neg := adder(), adder() for i := 0; i < 10; i++ { pos(i) neg(-2 * i) } TEQ(tardisgolib.CPos(), pos(0), 45) TEQ(tardisgolib.CPos(), neg(0), -90) // example from http://jordanorelli.tumblr.com/post/42369331748/function-types-in-go-golang x := 5 fn := func(y int) { TEQ(tardisgolib.CPos(), x, y) } fn(5) x++ fn(6) f := fib() TEQ(tardisgolib.CPos(), f(), 1) TEQ(tardisgolib.CPos(), f(), 1) TEQ(tardisgolib.CPos(), f(), 2) TEQ(tardisgolib.CPos(), f(), 3) TEQ(tardisgolib.CPos(), f(), 5) }
func main() { //println("Start test running in: " + tardisgolib.Platform()) testManyGoroutines() testChanSelect() tourfib() testCaseSensitivity() testInit() testConst() testUTF() testFloat() testMultiRet() testAppend() testStruct() testHeader() testCopy() testInFuncPtr() testCallBy() testMap() testNamed() testFuncPtr() testIntOverflow() testSlices() testChan() testComplex() testUTF8() testString() testClosure() testVariadic(42) testVariadic(40, 2) testVariadic(42, -5, 3, 2) testInterface() testInterfaceMethods() testStrconv() testTour64() testUintDiv32() testUintDiv64() testDefer() aGrWG.Wait() TEQint32(tardisgolib.CPos()+" testManyGoroutines() sync/atomic counter:", aGrCtr, 0) if tardisgolib.Host() == "haxe" { TEQ(tardisgolib.CPos(), int(tardisgolib.HAXE("42;")), int(42)) TEQ(tardisgolib.CPos(), string(tardisgolib.HAXE("'test';")), "test") TEQ(tardisgolib.CPos()+"Num Haxe GR post-wait", tardisgolib.NumGoroutine(), 1) } else { TEQ(tardisgolib.CPos()+"Num Haxe GR post-wait", tardisgolib.NumGoroutine(), 2) } //println("End test running in: " + tardisgolib.Platform()) //println("再见!Previous two chinese characters should say goodbye! (testing unicode output)") //println() }
func testFloat() { // and also slices! TEQfloat(tardisgolib.CPos(), Sqrt(1024), 32.0, 0.1) threeD := make([][][]float64, 10) for i := range threeD { threeD[i] = make([][]float64, 10) for j := range threeD[i] { threeD[i][j] = make([]float64, 10) for k := range threeD[i][j] { threeD[i][j][k] = float64(i) * float64(j) * float64(k) TEQfloat(tardisgolib.CPos(), threeD[i][j][k], float64(i)*float64(j)*float64(k), 0.1) } } } // TODO add more here }
func testVariadic(values ...int) { total := 0 for i := range values { total += values[i] } TEQ(tardisgolib.CPos(), total, 42) }
func (v Value) testFieldFn() { f0 := flag.mv(0, 42) f1 := flag.mv TEQ(tardisgolib.CPos(), f1(f0, 42), f0) rt = new(rtype) v.typ = rt v.typ.hash = 42 x := rt.hash TEQ(tardisgolib.CPos(), v.typ.hash, x) y := &rt.hash z := (*y) TEQ(tardisgolib.CPos(), z, x) var ff interface{} = &v.flag *(ff.(*flag)) = 42 var ffh interface{} = v.typ ffh.(*rtype).flag = f1(0, 42) TEQ(tardisgolib.CPos(), *(ff.(*flag)), ffh.(*rtype).flag) }
func testTour64() { a := []int{7, 2, 8, -9, 4, 0} c := make(chan int) go sum(a[:len(a)/2], c) go sum(a[len(a)/2:], c) x, y := <-c, <-c // receive from c TEQ(tardisgolib.CPos(), x+y, 12) // x & y could arrive in any order... }
func testString() { TEQ(tardisgolib.CPos(), aString <= "A", true) TEQ(tardisgolib.CPos(), aString <= aaString, true) TEQ(tardisgolib.CPos(), aString > aaString, false) TEQ(tardisgolib.CPos(), aString == aaString, false) TEQ(tardisgolib.CPos(), aString+aString == aaString, true) TEQ(tardisgolib.CPos(), bbString < aaString, false) }
func testAppend() { s0 := []int{0, 0} s1 := append(s0, 2) // append a single element s1 == []int{0, 0, 2} TEQintSlice(tardisgolib.CPos(), []int{0, 0, 2}, s1) s2 := append(s1, 3, 5, 7) // append multiple elements s2 == []int{0, 0, 2, 3, 5, 7} TEQintSlice(tardisgolib.CPos(), []int{0, 0, 2, 3, 5, 7}, s2) s3 := append(s2, s0...) // append a slice s3 == []int{0, 0, 2, 3, 5, 7, 0, 0} TEQintSlice(tardisgolib.CPos(), []int{0, 0, 2, 3, 5, 7, 0, 0}, s3) var t []interface{} t = append(t, 42, 3.1415, "foo", nil) // t == []interface{}{42, 3.1415, "foo"} TEQ(tardisgolib.CPos(), t[0], 42) TEQ(tardisgolib.CPos(), t[1], 3.1415) TEQ(tardisgolib.CPos(), t[2], "foo") TEQ(tardisgolib.CPos(), t[3], nil) var b []byte b = append(b, "bar"...) TEQbyteSlice(tardisgolib.CPos(), b, []byte{'b', 'a', 'r'}) }
func testDefer() { // examples from http://blog.golang.org/defer-panic-and-recover testDefer_a() b := make(chan int, 4) testDefer_b(b) TEQ(tardisgolib.CPos(), <-b, 3) TEQ(tardisgolib.CPos(), <-b, 2) TEQ(tardisgolib.CPos(), <-b, 1) TEQ(tardisgolib.CPos(), <-b, 0) TEQ(tardisgolib.CPos(), testDefer_c(), 2) protect(g) TEQ(tardisgolib.CPos(), tddCount, 6) }
func testStruct() { var PrivateStruct struct { a int b bool c string d float64 e interface{} f [12]int g [6]string h [14]struct { x bool y [3]float64 z [6]interface{} } } // check that everything is equally initialized TEQ(tardisgolib.CPos(), PublicStruct.a, PrivateStruct.a) TEQ(tardisgolib.CPos(), PublicStruct.b, PrivateStruct.b) TEQ(tardisgolib.CPos(), PublicStruct.c, PrivateStruct.c) TEQ(tardisgolib.CPos(), PublicStruct.d, PrivateStruct.d) TEQ(tardisgolib.CPos(), PublicStruct.e, PrivateStruct.e) TEQintSlice(tardisgolib.CPos(), PublicStruct.f[:], PrivateStruct.f[:]) PublicStruct.a = 42 PrivateStruct.a = 42 TEQ(tardisgolib.CPos(), PublicStruct.a, PrivateStruct.a) PublicStruct.c = Name PrivateStruct.c = Name TEQ(tardisgolib.CPos(), PublicStruct.c, PrivateStruct.c) for i := range PrivateStruct.h { for j := range PrivateStruct.h[i].y { PrivateStruct.h[i].y[j] = 42.0 * float64(i) * float64(j) PublicStruct.h[i].y[j] = 42.0 * float64(i) * float64(j) TEQfloat(tardisgolib.CPos(), PrivateStruct.h[i].y[j], PublicStruct.h[i].y[j], 1.0) } } }
func testCopy() { var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7} var s = make([]int, 6) n1 := copy(s, a[0:]) // n1 == 6, s == []int{0, 1, 2, 3, 4, 5} TEQ(tardisgolib.CPos(), n1, 6) TEQintSlice(tardisgolib.CPos(), s, []int{0, 1, 2, 3, 4, 5}) n2 := copy(s, s[2:]) // n2 == 4, s == []int{2, 3, 4, 5, 4, 5} TEQ(tardisgolib.CPos(), n2, 4) TEQintSlice(tardisgolib.CPos(), s, []int{2, 3, 4, 5, 4, 5}) var b = make([]byte, 5) n3 := copy(b, "Hello, World!") // n3 == 5, b == []byte("Hello") TEQ(tardisgolib.CPos(), n3, 5) TEQbyteSlice(tardisgolib.CPos(), b, []byte("Hello")) }
func testInterface() { var i interface{} i = "test" if i.(string) != "test" { println("testInterface string not equal 'test':") println(i) } i = int(42) if i.(int) != 42 { println("testInterface int not equal 42:") println(i) } j, ok := i.(rune) if ok { println("error rune!=int") } TEQ(tardisgolib.CPos(), j, rune(0)) }
func testUTF() { var ( rA, rB, r []rune uS, s1, s2 string ) rA = []rune{0x767d, 0x9d6c, 0x7fd4} uS = string(rA) // "\u767d\u9d6c\u7fd4" == "白鵬翔" rB = []rune(uS) TEQruneSlice(tardisgolib.CPos(), rA, rB) s1 = "香港发生工厂班车砍人案12人受伤" r = []rune(s1) s2 = string(r) TEQ(tardisgolib.CPos(), s1, s2) TEQ(tardisgolib.CPos(), len(s1), 44) TEQ(tardisgolib.CPos(), len(testUTFlength), 9) hellø := "hellø" TEQ(tardisgolib.CPos(), string([]byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'}), hellø) TEQbyteSlice(tardisgolib.CPos(), []byte("hellø"), []byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'}) TEQ(tardisgolib.CPos(), "ø", hellø[4:]) }
func testChan() { c := make(chan int, 2) c <- 1 c <- 2 close(c) TEQ(tardisgolib.CPos(), <-c, 1) TEQ(tardisgolib.CPos(), <-c, 2) v, ok := <-c TEQ(tardisgolib.CPos(), v, 0) TEQ(tardisgolib.CPos(), ok, false) ch := make(chan bool, 2) ch <- true ch <- true close(ch) rangeCount := 0 for v := range ch { TEQ(tardisgolib.CPos(), v, true) rangeCount++ } TEQ(tardisgolib.CPos(), rangeCount, 2) //TODO much more to come here... }
func testUTF8() { b := []byte("Hello, 世界") r, size := utf8.DecodeLastRune(b) TEQ(tardisgolib.CPos(), '界', r) TEQ(tardisgolib.CPos(), size, 3) b = b[:len(b)-size] r, size = utf8.DecodeLastRune(b) TEQ(tardisgolib.CPos(), '世', r) TEQ(tardisgolib.CPos(), size, 3) b = b[:len(b)-size] r, size = utf8.DecodeLastRune(b) TEQ(tardisgolib.CPos(), ' ', r) TEQ(tardisgolib.CPos(), size, 1) str := "Hello, 世界" r, size = utf8.DecodeLastRuneInString(str) TEQ(tardisgolib.CPos(), '界', r) TEQ(tardisgolib.CPos(), size, 3) str = str[:len(str)-size] r, size = utf8.DecodeLastRuneInString(str) TEQ(tardisgolib.CPos(), '世', r) TEQ(tardisgolib.CPos(), size, 3) str = str[:len(str)-size] r, size = utf8.DecodeLastRuneInString(str) TEQ(tardisgolib.CPos(), ' ', r) TEQ(tardisgolib.CPos(), size, 1) ru := '世' buf := make([]byte, 3) n := utf8.EncodeRune(buf, ru) TEQ(tardisgolib.CPos(), n, 3) TEQbyteSlice(tardisgolib.CPos(), buf, []byte{228, 184, 150}) buf = []byte{228, 184, 150} // 世 TEQ(tardisgolib.CPos(), true, utf8.FullRune(buf)) TEQ(tardisgolib.CPos(), false, utf8.FullRune(buf[:2])) str = "世" TEQ(tardisgolib.CPos(), true, utf8.FullRuneInString(str)) if ShowKnownErrors || tardisgolib.Zilen() == 3 { TEQ(tardisgolib.CPos()+" NOTE: known error handling incorrect strings on UTF16 platforms", false, utf8.FullRuneInString(str[:2])) } buf = []byte("Hello, 世界") TEQ(tardisgolib.CPos(), 13, len(buf)) TEQ(tardisgolib.CPos(), 9, utf8.RuneCount(buf)) str = "Hello, 世界" TEQ(tardisgolib.CPos(), 13, len(str)) TEQ(tardisgolib.CPos(), 9, utf8.RuneCountInString(str)) TEQ(tardisgolib.CPos(), 1, utf8.RuneLen('a')) TEQ(tardisgolib.CPos(), 3, utf8.RuneLen('界')) buf = []byte("a界") TEQ(tardisgolib.CPos(), true, utf8.RuneStart(buf[0])) TEQ(tardisgolib.CPos(), true, utf8.RuneStart(buf[1])) TEQ(tardisgolib.CPos(), false, utf8.RuneStart(buf[2])) valid := []byte("Hello, 世界") invalid := []byte{0xff, 0xfe, 0xfd} TEQ(tardisgolib.CPos(), true, utf8.Valid(valid)) TEQ(tardisgolib.CPos(), false, utf8.Valid(invalid)) valid_rune := 'a' invalid_rune := rune(0xfffffff) TEQ(tardisgolib.CPos(), true, utf8.ValidRune(valid_rune)) TEQ(tardisgolib.CPos(), false, utf8.ValidRune(invalid_rune)) valid_string := "Hello, 世界" invalid_string := string([]byte{0xff, 0xfe, 0xfd}) TEQ(tardisgolib.CPos(), true, utf8.ValidString(valid_string)) if ShowKnownErrors || tardisgolib.Zilen() == 3 { TEQ(tardisgolib.CPos()+" NOTE: known error handling incorrect strings on UTF16 platforms", false, utf8.ValidString(invalid_string)) } }
func testSlices() { // from the Go tour... p := []int{2, 3, 5, 7, 11, 13} TEQintSlice(tardisgolib.CPos(), p[1:4], []int{3, 5, 7}) TEQintSlice(tardisgolib.CPos(), p[:3], []int{2, 3, 5}) TEQintSlice(tardisgolib.CPos(), p[4:], []int{11, 13}) a := make([]int, 5) TEQintSlice(tardisgolib.CPos(), a, []int{0, 0, 0, 0, 0}) TEQ(tardisgolib.CPos(), len(a), 5) TEQ(tardisgolib.CPos(), cap(a), 5) b := make([]int, 0, 5) TEQintSlice(tardisgolib.CPos(), b, []int{}) TEQ(tardisgolib.CPos(), len(b), 0) TEQ(tardisgolib.CPos(), cap(b), 5) c := b[:2] TEQintSlice(tardisgolib.CPos(), c, []int{0, 0}) TEQ(tardisgolib.CPos(), len(c), 2) TEQ(tardisgolib.CPos(), cap(c), 5) d := c[2:5] TEQintSlice(tardisgolib.CPos(), d, []int{0, 0, 0}) TEQ(tardisgolib.CPos(), len(d), 3) TEQ(tardisgolib.CPos(), cap(d), 3) var z []int TEQ(tardisgolib.CPos(), len(z), 0) TEQ(tardisgolib.CPos(), cap(z), 0) TEQ(tardisgolib.CPos(), z == nil, true) }
func testIntOverflow() { //TODO add int64 TEQ(tardisgolib.CPos()+" int16 overflow test 1", int16_max+1, int16_mostNeg) TEQ(tardisgolib.CPos()+" int8 overflow test 1", int8_max+1, int8_mostNeg) TEQ(tardisgolib.CPos()+" uint16 overflow test 2", uint16(uint16_max+1), uint16(0)) TEQ(tardisgolib.CPos()+" uint8 overflow test 2", uint8(uint8_max+1), uint8(0)) TEQ(tardisgolib.CPos()+" int8 overflow test 3", int8(int8_mostNeg-1), int8_max) TEQ(tardisgolib.CPos()+" int16 overflow test 3", int16(int16_mostNeg-1), int16_max) TEQint64(tardisgolib.CPos()+" int64 overflow test 1 ", int64_max+1, int64_mostNeg) TEQint32(tardisgolib.CPos()+" int32 overflow test 1 ", int32_max+1, int32_mostNeg) TEQuint64(tardisgolib.CPos()+" uint64 overflow test 2 ", uint64(uint64_max+1), uint64(0)) TEQuint32(tardisgolib.CPos()+" uint32 overflow test 2 ", uint32(uint32_max+1), uint32(0)) TEQint32(tardisgolib.CPos()+" int32 overflow test 3 ", int32(int32_mostNeg-int32(1)), int32_max) TEQint64(tardisgolib.CPos()+" int64 overflow test 3 ", int64(int64_mostNeg-int64(1)), int64_max) //Math.imul test case at https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul TEQuint32(tardisgolib.CPos(), ((uint32_max << 1) * 5), uint32_max+1-10) TEQuint32(tardisgolib.CPos(), (((uint32_max << 1) + 1) * 5), uint32_max+1-5) /* from Go spec: For two integer values x and y, the integer quotient q = x / y and remainder r = x % y satisfy the following relationships: x = q*y + r and |r| < |y| with x / y truncated towards zero ("truncated division"). x y x / y x % y 5 3 1 2 -5 3 -1 -2 5 -3 -1 2 -5 -3 1 -2 */ TEQ(tardisgolib.CPos(), five/three, 1) TEQ(tardisgolib.CPos(), five%three, 2) TEQ(tardisgolib.CPos(), (-five)/three, -1) TEQ(tardisgolib.CPos(), (-five)%three, -2) TEQ(tardisgolib.CPos(), five/(-three), -1) TEQ(tardisgolib.CPos(), five%(-three), 2) TEQ(tardisgolib.CPos(), (-five)/(-three), 1) TEQ(tardisgolib.CPos(), (-five)%(-three), -2) TEQint64(tardisgolib.CPos(), int64(five)/int64(three), int64(1)) TEQint64(tardisgolib.CPos(), int64(five)%int64(three), int64(2)) TEQint64(tardisgolib.CPos(), int64(-five)/int64(three), int64(-1)) TEQint64(tardisgolib.CPos(), int64(-five)%int64(three), int64(-2)) TEQint64(tardisgolib.CPos(), int64(five)/int64(-three), int64(-1)) TEQint64(tardisgolib.CPos(), int64(five)%int64(-three), int64(2)) TEQint64(tardisgolib.CPos(), int64(-five)/int64(-three), int64(1)) TEQint64(tardisgolib.CPos(), int64(-five)%int64(-three), int64(-2)) /* As an exception to this rule, if the dividend x is the most negative value for the int type of x, the quotient q = x / -1 is equal to x (and r = 0). */ TEQint64(tardisgolib.CPos()+" int64 div special case", int64_mostNeg/int64(-1), int64_mostNeg) TEQint64(tardisgolib.CPos()+" int64 mod special case", int64_mostNeg%int64(-1), 0) TEQint32(tardisgolib.CPos()+" int32 div special case", int32(int32_mostNeg/int32(-1)), int32_mostNeg) TEQint32(tardisgolib.CPos()+" int32 mod special case", int32_mostNeg%int32(-1), 0) if int16(int16_mostNeg/int16(-1)) != int16_mostNeg { println(tardisgolib.CPos() + " int16 div special case") } if int16(int16_mostNeg%int16(-1)) != int16(0) { println(tardisgolib.CPos() + " int16 mod special case") } if int8(int8_mostNeg/int8(-1)) != int8_mostNeg { println(tardisgolib.CPos() + " int8 div special case") } if int8(int8_mostNeg%int8(-1)) != int8(0) { println(tardisgolib.CPos() + " int8 mod special case") } /*THESE VALUES ARE NOT IN THE SPEC, SO UNTESTED if uint64(int64_mostNeg)/0xFFFFFFFFFFFFFFFF == uint64(int64_mostNeg) { println(tardisgolib.CPos() + " uint64 div special case") } if uint64(int64_mostNeg)%0xFFFFFFFFFFFFFFFF == uint64(0) { println(tardisgolib.CPos() + " uint64 mod special case") } if uint32(int32_mostNeg)/0xFFFFFFFF == uint32(int32_mostNeg) { println(tardisgolib.CPos() + " uint32 div special case") } if uint32(int32_mostNeg)%0xFFFFFFFF == uint32(0) { println(tardisgolib.CPos() + " uint32 mod special case") } if uint16(int16_mostNeg)/0xFFFF == uint16(int16_mostNeg) { println(tardisgolib.CPos() + " uint16 div special case") } if uint16(int16_mostNeg)%0xFFFF == uint16(0) { println(tardisgolib.CPos() + " uint16 mod special case") } if uint8(int8_mostNeg)/0xFF == uint8(int8_mostNeg) { println(tardisgolib.CPos() + " uint8 div special case") } if uint8(int8_mostNeg)%0xFF == uint8(0) { println(tardisgolib.CPos() + " uint8 mod special case") } */ //TODO more tests for unsigned comparisons, need to check all possibilities are covered TEQ(tardisgolib.CPos(), uint8(int8_mostNeg) > uint8(0), true) TEQ(tardisgolib.CPos(), uint8(int8_mostNeg) < uint8(0), false) TEQ(tardisgolib.CPos(), uint16(int16_mostNeg) > uint16(0), true) TEQ(tardisgolib.CPos(), uint16(int16_mostNeg) < uint16(0), false) TEQ(tardisgolib.CPos(), uint32(int32_mostNeg) > uint32(0), true) TEQ(tardisgolib.CPos(), uint32(int32_mostNeg) < uint32(0), false) TEQ(tardisgolib.CPos()+" uint64(int64_mostNeg) > uint64(0) ", uint64(int64_mostNeg) > uint64(0), true) TEQ(tardisgolib.CPos(), uint64(int64_mostNeg) < uint64(0), false) //TEQint64(tardisgolib.CPos(), int64(int64_mostNeg), int64(uint64(0x8000000000000000))) //println(float64(int64_mostNeg)) //println(int64_mostNeg) uint64Global = uint64(int64_mostNeg) TEQuint64(tardisgolib.CPos(), uint64Global, uint64(0x8000000000000000)) for i := range uint64GlobalArray { uint64GlobalArray[i] = uint64(int64_mostNeg) TEQ(tardisgolib.CPos()+" uint64(int64_mostNeg) > uint64(0) [Array] ", uint64(uint64GlobalArray[i]) > uint64(0), true) } // TODO test for equality too & check these constants are not being resolved by the compiler, rather than genereating tests! TEQ(tardisgolib.CPos(), uint8(int8_mostNeg)-uint8(42) > uint8(0), true) TEQ(tardisgolib.CPos(), uint8(int8_mostNeg)-uint8(42) < uint8(three), false) TEQ(tardisgolib.CPos(), uint16(int16_mostNeg)-uint16(42) > uint16(0), true) TEQ(tardisgolib.CPos(), uint16(0xffff)-uint16(five) < uint16(three), false) TEQ(tardisgolib.CPos(), uint32(0xffffffff)-uint32(five) > uint32(0), true) TEQ(tardisgolib.CPos(), uint32(0xffffffff)-uint32(five) < uint32(three), false) TEQ(tardisgolib.CPos(), uint64(0xffffffffffffffff)-uint64(five) > uint64(0), true) TEQ(tardisgolib.CPos(), uint64(0xffffffffffffffff)-uint64(five) < uint64(three), false) TEQ(tardisgolib.CPos(), uint8(0xff) > uint8(0xfe)-uint8(five), true) TEQ(tardisgolib.CPos(), uint8(five) < uint8(three), false) TEQ(tardisgolib.CPos(), uint16(0xffff) > uint16(0xfffe)-uint16(five), true) TEQ(tardisgolib.CPos(), uint16(10000)-uint16(five) < uint16(1000), false) TEQ(tardisgolib.CPos(), uint32(0xffffffff) > uint32(0xfffffffe)-uint32(five), true) TEQ(tardisgolib.CPos(), uint32(12)-uint32(five) < uint32(three), false) TEQ(tardisgolib.CPos(), uint64(0xffffffffffffffff) > uint64(0xfffffffffffffffe)-uint64(five), true) TEQ(tardisgolib.CPos(), uint64(12)-uint64(five) < uint64(three), false) // test Float / Int64 conversions fiveI64 := int64(five) TEQfloat(tardisgolib.CPos(), float64(fiveI64), 5.0, 0.1) TEQfloat(tardisgolib.CPos(), float64(int32_mostNeg), float64(-2147483648.0), 0.1) TEQfloat(tardisgolib.CPos()+" PHP error", float64(int64_mostNeg/int64(100000)), float64(int64(-9223372036854775808)/int64(100000)), float64(1.0)) TEQfloat(tardisgolib.CPos()+" PHP error ", float64(int64_max/200), float64(int64(0x7fffffffffffffff)/200), float64(10.0)) TEQfloat(tardisgolib.CPos(), float64(int64_mostNeg+1), float64(int64(-9223372036854775808+1)), float64(2000.0)) TEQfloat(tardisgolib.CPos(), float64(int64_mostNeg), float64(int64(-9223372036854775808)), float64(2000.0)) TEQfloat(tardisgolib.CPos(), float64(uint64Global), float64(int64(0x7fffffffffffffff)), float64(2000.0)) uint64Global = 0xFFFFFFFFFFFFFFFF TEQfloat(tardisgolib.CPos(), float64(uint64Global), float64(uint64(0xffffffffffffffff)), float64(2000.0)) // tests below removed to avoid also loading the math package //TEQint64(tardisgolib.CPos()+" NaN ->int64 conversion", int64(math.NaN()), -9223372036854775808) //TEQuint64(tardisgolib.CPos()+" NaN ->uint64 conversion (error on php)", uint64(math.NaN()), 9223372036854775808) myPi := float64(7) myPi64 := int64(myPi) myPu64 := uint64(myPi) limit := float64(1 << 52) for myPi < limit { a := TEQint64(tardisgolib.CPos()+" +ve float->int64 conversion ", int64(myPi), myPi64) b := TEQint64(tardisgolib.CPos()+" -ve float->int64 conversion ", int64(-myPi), -myPi64) c := TEQuint64(tardisgolib.CPos()+" float->uint64 conversion ", uint64(myPi), myPu64) if a == false || b == false || c == false { break } myPi *= myPi myPi64 *= myPi64 myPu64 *= myPu64 } }
func testFuncPtr() { var hypot2 = func(x, y float64) float64 { return Sqrt(x*x + y*y) } TEQfloat(tardisgolib.CPos(), hypot1(3, 4), hypot2(3, 4), 0.2) }
func testNamed() { var ia IntArray for i := range ia { ia[i] = i } TEQintSlice(tardisgolib.CPos(), ia[:], []int{0, 1, 2, 3, 4, 5, 6, 7}) var namedLocal MyFloat = 41.42 namedGlobal = 42.42 namedLocal += 1.0 TEQfloat(tardisgolib.CPos(), float64(namedGlobal), float64(namedLocal), 0.0002) myPolar.x = 11.11 myPolar.y = 10.11 myPolar.y++ TEQfloat(tardisgolib.CPos(), float64(myPolar.x), float64(myPolar.y), 0.0002) // method expression tests... TEQ(tardisgolib.CPos(), myPolar.BearVal(), true) f := MyFloat(-555) g := MyFloat2(-555) TEQfloat(tardisgolib.CPos(), f.Abs(), g.Abs(), 0.0002) ia.set42() f.set42() TEQfloat(tardisgolib.CPos(), float64(ia[3]), float64(f), 0.0002) // from the language spec section on method values (requires ssa.MakeClosure instruction) f1 := t.Mv TEQ(tardisgolib.CPos(), f1(7), t.Mv(7)) pt = &t f2 := pt.Mp TEQ(tardisgolib.CPos(), f2(7), pt.Mp(7)) f3 := pt.Mv TEQ(tardisgolib.CPos(), f3(7), (*pt).Mv(7)) f4 := t.Mp TEQ(tardisgolib.CPos(), f4(7), (&t).Mp(7)) // more from the language spec on Method expressions TEQ(tardisgolib.CPos(), t.Mv(7), T.Mv(t, 7)) TEQ(tardisgolib.CPos(), t.Mv(7), (T).Mv(t, 7)) f1a := T.Mv TEQ(tardisgolib.CPos(), t.Mv(7), f1a(t, 7)) f2a := (T).Mv TEQ(tardisgolib.CPos(), t.Mv(7), f2a(t, 7)) }
func testInterfaceMethods() { var v0 Value v0.testFieldFn() v := &Vertex{3, 4} TEQfloat(tardisgolib.CPos(), v.Abs(), 5, 0.00001) TEQfloat(tardisgolib.CPos(), v.Scale(5), 25, 0.001) TEQfloat(tardisgolib.CPos(), v.X, 15, 0.0000001) TEQfloat(tardisgolib.CPos(), v.Y, 20, 0.0000001) var a Abser f := MyFloat(-42) vt := Vertex{3, 4} a = f // a MyFloat implements Abser x, ok := a.(Abser) //println(reflect.TypeOf(x).String()) => main.MyFloat if !ok { println("Error in testInterfaceMethods(): MyFloat should be in Abser interface") } TEQ(tardisgolib.CPos()+"testInterfaceMethods():MyFloat in Abser", a, f) TEQ(tardisgolib.CPos()+"testInterfaceMethods():MyFloat.Abs()", a.Abs(), float64(42)) TEQ(tardisgolib.CPos()+"testInterfaceMethods():x.Abs()", x.Abs(), float64(42)) TEQ(tardisgolib.CPos()+"testInterfaceMethods():MyFloat.Scale(10)", a.Scale(10), float64(-420)) TEQ(tardisgolib.CPos()+"testInterfaceMethods():x.Scale(10)", x.Scale(10), float64(-420)) a = &vt // a *Vertex implements Abser y, ok := a.(Abser) //println(reflect.TypeOf(y).String()) => *main.Vertex if !ok { println("Error in testInterfaceMethods(): Vertex should be in Abser interface") } TEQ(tardisgolib.CPos()+"testInterfaceMethods():*Vertex in Abser", a, &vt) TEQfloat(tardisgolib.CPos()+"testInterfaceMethods():*Vertex.Abs()", a.Abs(), float64(5), 0.000001) TEQfloat(tardisgolib.CPos()+"testInterfaceMethods():y.Abs()", y.Abs(), float64(5), 0.000001) TEQfloat(tardisgolib.CPos()+"testInterfaceMethods():*Vertex.Scale(10)", a.Scale(10), float64(50), 0.000001) TEQfloat(tardisgolib.CPos()+"testInterfaceMethods():y.Scale(10)", y.Scale(10), float64(653.35), 0.01) // a=vt // a Vertex, does NOT //from the go.tools/go/types documentation p0 = new(T0) // TODO should fail with this line missing, but does not (globals pre-initialised when they should not be) p0.X = 42 TEQfloat(tardisgolib.CPos(), p0.X, 42.0, 0.01) }
func protect(g func(int)) { defer func() { TEQ(tardisgolib.CPos(), recover(), "test panic") }() g(0) }
func testComplex() { var x, y, z complex64 var ss complex128 x = 1 + 2i TEQfloat(tardisgolib.CPos(), float64(real(x)), 1, 0.1) TEQfloat(tardisgolib.CPos(), float64(imag(x)), 2, 0.1) y = complex(3, 4) TEQfloat(tardisgolib.CPos(), float64(real(y)), 3, 0.1) TEQfloat(tardisgolib.CPos(), float64(imag(y)), 4, 0.1) //this previously failed in the SSA interpreter z = -x TEQfloat(tardisgolib.CPos(), float64(real(z)), -1, 0.1) TEQfloat(tardisgolib.CPos(), float64(imag(z)), -2, 0.1) z = x + y TEQfloat(tardisgolib.CPos(), float64(real(z)), 4, 0.1) TEQfloat(tardisgolib.CPos(), float64(imag(z)), 6, 0.1) z = x - y TEQfloat(tardisgolib.CPos(), float64(real(z)), -2, 0.1) TEQfloat(tardisgolib.CPos(), float64(imag(z)), -2, 0.1) z = x + y - y TEQfloat(tardisgolib.CPos(), float64(real(z)), float64(real(x)), 0.1) TEQfloat(tardisgolib.CPos(), float64(imag(z)), float64(imag(x)), 0.1) /* z = x * y printf64("real(x*y)", float64(real(z))) printf64("imag(x*y)", float64(imag(z))) z = x / y printf64("real(x/y)", float64(real(z))) printf64("imag(x/y)", float64(imag(z))) */ z = x * y / y TEQfloat(tardisgolib.CPos(), float64(real(z)), float64(real(x)), 0.1) TEQfloat(tardisgolib.CPos(), float64(imag(z)), float64(imag(x)), 0.1) TEQ(tardisgolib.CPos(), x == y, false) TEQ(tardisgolib.CPos(), x != y, true) ss = complex128(x) tt := complex128(y) TEQ(tardisgolib.CPos(), ss != tt, true) }
func testConst() { TEQ(tardisgolib.CPos(), Name, "this is my name") TEQ(tardisgolib.CPos(), ests, true) TEQfloat(tardisgolib.CPos(), Pi, 3.14159265358979323846, 0.00000000000001) TEQ(tardisgolib.CPos(), zero, 0.0) // untyped floating-point constant TEQ(tardisgolib.CPos(), size, 1024) TEQ(tardisgolib.CPos(), eof, -1) // untyped integer constant // a = 3, b = 4, c = "foo", untyped integer and string constants TEQ(tardisgolib.CPos(), a, 3) TEQ(tardisgolib.CPos(), b, 4) TEQ(tardisgolib.CPos(), c, "foo") // u = 0.0, v = 3.0 TEQ(tardisgolib.CPos(), u, 0.0) TEQ(tardisgolib.CPos(), v, 3.0) TEQ(tardisgolib.CPos(), Sunday, 0) TEQ(tardisgolib.CPos(), Monday, 1) TEQ(tardisgolib.CPos(), Tuesday, 2) TEQ(tardisgolib.CPos(), Wednesday, 3) TEQ(tardisgolib.CPos(), Thursday, 4) TEQ(tardisgolib.CPos(), Friday, 5) TEQ(tardisgolib.CPos(), Partyday, 6) TEQ(tardisgolib.CPos(), numberOfDays, 7) // this constant is not exported TEQ(tardisgolib.CPos(), c0, 0) // c0 == 0 TEQ(tardisgolib.CPos(), c1, 1) // c1 == 1 TEQ(tardisgolib.CPos(), c2, 2) // c2 == 2 TEQ(tardisgolib.CPos(), _a, 1) // a == 1 (iota has been reset) TEQ(tardisgolib.CPos(), _b, 2) // b == 2 TEQ(tardisgolib.CPos(), _c, 4) // c == 4 TEQ(tardisgolib.CPos(), _u, 0) // u == 0 (untyped integer constant) TEQ(tardisgolib.CPos(), _v, 42.0) // v == 42.0 (float64 constant) TEQ(tardisgolib.CPos(), _w, 84) // w == 84 (untyped integer constant) TEQ(tardisgolib.CPos(), _x, 0) // x == 0 (iota has been reset) TEQ(tardisgolib.CPos(), _y, 0) // y == 0 (iota has been reset) TEQ(tardisgolib.CPos(), bit0, 1) TEQ(tardisgolib.CPos(), mask0, 0) // bit0 == 1, mask0 == 0 TEQ(tardisgolib.CPos(), bit1, 2) TEQ(tardisgolib.CPos(), mask1, 1) // bit1 == 2, mask1 == 1 //_, _ // skips iota == 2 TEQ(tardisgolib.CPos(), bit3, 8) TEQ(tardisgolib.CPos(), mask3, 7) // bit3 == 8, mask3 == 7 TEQ(tardisgolib.CPos(), ren, '人') TEQ(tardisgolib.CPos(), Θ, 1.0) // Θ == 1.0 (type float64, 3/2 is integer division) TEQ(tardisgolib.CPos(), Π, 1.5) // Π == 1.5 (type float64, 3/2. is float division) TEQ(tardisgolib.CPos(), d, 8) // d == 8 (untyped integer constant) TEQ(tardisgolib.CPos(), e, 8) // e == 8 (untyped integer constant) TEQ(tardisgolib.CPos(), h, true) // h == true (untyped boolean constant) TEQ(tardisgolib.CPos(), j, true) // j == true (untyped boolean constant) TEQ(tardisgolib.CPos(), k, 'x') // k == 'x' (untyped rune constant) TEQ(tardisgolib.CPos(), l, "hi") // l == "hi" (untyped string constant) TEQ(tardisgolib.CPos(), m, "x") // m == "x" (type string) }
func testMultiRet() { r1, r2 := twoRets(1) TEQ(tardisgolib.CPos(), r1, 42) TEQ(tardisgolib.CPos(), r2, "forty-two") }
func testDefer_a() { i := 0 defer TEQ(tardisgolib.CPos(), i, 0) i++ return }
func testInit() { TEQ(tardisgolib.CPos(), TestInit, "init() ran OK") TEQintSlice(tardisgolib.CPos(), primes[:], []int{2, 3, 5, 7, 9, 2147483647}) TEQ(tardisgolib.CPos(), 9, primes[4]) // also testing array access with a constant index TEQ(tardisgolib.CPos(), nil, iFace) }
func testCaseSensitivity() { TEQ(tardisgolib.CPos(), ilogb(64), Ilogb(64)) }
func testInFuncPtr() { // there is no way to stop this use of pointers... var ss = 12 var ssa = &ss TEQ(tardisgolib.CPos(), *ssa, 12) }