| // Copyright 2016 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. |
| |
| // This program generates a test to verify that the standard arithmetic |
| // operators properly handle const cases. The test file should be |
| // generated with a known working version of go. |
| // launch with `go run arithConstGen.go` a file called arithConst.go |
| // will be written into the parent directory containing the tests |
| |
| package main |
| |
| import ( |
| "bytes" |
| "fmt" |
| "go/format" |
| "io/ioutil" |
| "log" |
| "strings" |
| "text/template" |
| ) |
| |
| type op struct { |
| name, symbol string |
| } |
| type szD struct { |
| name string |
| sn string |
| u []uint64 |
| i []int64 |
| oponly string |
| } |
| |
| var szs = []szD{ |
| {name: "uint64", sn: "64", u: []uint64{0, 1, 4294967296, 0x8000000000000000, 0xffffFFFFffffFFFF}}, |
| {name: "uint64", sn: "64", u: []uint64{3, 5, 7, 9, 10, 11, 13, 19, 21, 25, 27, 37, 41, 45, 73, 81}, oponly: "mul"}, |
| |
| {name: "int64", sn: "64", i: []int64{-0x8000000000000000, -0x7FFFFFFFFFFFFFFF, |
| -4294967296, -1, 0, 1, 4294967296, 0x7FFFFFFFFFFFFFFE, 0x7FFFFFFFFFFFFFFF}}, |
| {name: "int64", sn: "64", i: []int64{-9, -5, -3, 3, 5, 7, 9, 10, 11, 13, 19, 21, 25, 27, 37, 41, 45, 73, 81}, oponly: "mul"}, |
| |
| {name: "uint32", sn: "32", u: []uint64{0, 1, 4294967295}}, |
| {name: "uint32", sn: "32", u: []uint64{3, 5, 7, 9, 10, 11, 13, 19, 21, 25, 27, 37, 41, 45, 73, 81}, oponly: "mul"}, |
| |
| {name: "int32", sn: "32", i: []int64{-0x80000000, -0x7FFFFFFF, -1, 0, |
| 1, 0x7FFFFFFF}}, |
| {name: "int32", sn: "32", i: []int64{-9, -5, -3, 3, 5, 7, 9, 10, 11, 13, 19, 21, 25, 27, 37, 41, 45, 73, 81}, oponly: "mul"}, |
| |
| {name: "uint16", sn: "16", u: []uint64{0, 1, 65535}}, |
| {name: "int16", sn: "16", i: []int64{-32768, -32767, -1, 0, 1, 32766, 32767}}, |
| |
| {name: "uint8", sn: "8", u: []uint64{0, 1, 255}}, |
| {name: "int8", sn: "8", i: []int64{-128, -127, -1, 0, 1, 126, 127}}, |
| } |
| |
| var ops = []op{ |
| {"add", "+"}, |
| {"sub", "-"}, |
| {"div", "/"}, |
| {"mul", "*"}, |
| {"lsh", "<<"}, |
| {"rsh", ">>"}, |
| {"mod", "%"}, |
| {"and", "&"}, |
| {"or", "|"}, |
| {"xor", "^"}, |
| } |
| |
| // compute the result of i op j, cast as type t. |
| func ansU(i, j uint64, t, op string) string { |
| var ans uint64 |
| switch op { |
| case "+": |
| ans = i + j |
| case "-": |
| ans = i - j |
| case "*": |
| ans = i * j |
| case "/": |
| if j != 0 { |
| ans = i / j |
| } |
| case "%": |
| if j != 0 { |
| ans = i % j |
| } |
| case "<<": |
| ans = i << j |
| case ">>": |
| ans = i >> j |
| case "&": |
| ans = i & j |
| case "|": |
| ans = i | j |
| case "^": |
| ans = i ^ j |
| } |
| switch t { |
| case "uint32": |
| ans = uint64(uint32(ans)) |
| case "uint16": |
| ans = uint64(uint16(ans)) |
| case "uint8": |
| ans = uint64(uint8(ans)) |
| } |
| return fmt.Sprintf("%d", ans) |
| } |
| |
| // compute the result of i op j, cast as type t. |
| func ansS(i, j int64, t, op string) string { |
| var ans int64 |
| switch op { |
| case "+": |
| ans = i + j |
| case "-": |
| ans = i - j |
| case "*": |
| ans = i * j |
| case "/": |
| if j != 0 { |
| ans = i / j |
| } |
| case "%": |
| if j != 0 { |
| ans = i % j |
| } |
| case "<<": |
| ans = i << uint64(j) |
| case ">>": |
| ans = i >> uint64(j) |
| case "&": |
| ans = i & j |
| case "|": |
| ans = i | j |
| case "^": |
| ans = i ^ j |
| } |
| switch t { |
| case "int32": |
| ans = int64(int32(ans)) |
| case "int16": |
| ans = int64(int16(ans)) |
| case "int8": |
| ans = int64(int8(ans)) |
| } |
| return fmt.Sprintf("%d", ans) |
| } |
| |
| func main() { |
| w := new(bytes.Buffer) |
| fmt.Fprintf(w, "// Code generated by gen/arithConstGen.go. DO NOT EDIT.\n\n") |
| fmt.Fprintf(w, "package main;\n") |
| fmt.Fprintf(w, "import \"testing\"\n") |
| |
| fncCnst1 := template.Must(template.New("fnc").Parse( |
| `//go:noinline |
| func {{.Name}}_{{.Type_}}_{{.FNumber}}(a {{.Type_}}) {{.Type_}} { return a {{.Symbol}} {{.Number}} } |
| `)) |
| fncCnst2 := template.Must(template.New("fnc").Parse( |
| `//go:noinline |
| func {{.Name}}_{{.FNumber}}_{{.Type_}}(a {{.Type_}}) {{.Type_}} { return {{.Number}} {{.Symbol}} a } |
| `)) |
| |
| type fncData struct { |
| Name, Type_, Symbol, FNumber, Number string |
| } |
| |
| for _, s := range szs { |
| for _, o := range ops { |
| if s.oponly != "" && s.oponly != o.name { |
| continue |
| } |
| fd := fncData{o.name, s.name, o.symbol, "", ""} |
| |
| // unsigned test cases |
| if len(s.u) > 0 { |
| for _, i := range s.u { |
| fd.Number = fmt.Sprintf("%d", i) |
| fd.FNumber = strings.Replace(fd.Number, "-", "Neg", -1) |
| |
| // avoid division by zero |
| if o.name != "mod" && o.name != "div" || i != 0 { |
| // introduce uint64 cast for rhs shift operands |
| // if they are too large for default uint type |
| number := fd.Number |
| if (o.name == "lsh" || o.name == "rsh") && uint64(uint32(i)) != i { |
| fd.Number = fmt.Sprintf("uint64(%s)", number) |
| } |
| fncCnst1.Execute(w, fd) |
| fd.Number = number |
| } |
| |
| fncCnst2.Execute(w, fd) |
| } |
| } |
| |
| // signed test cases |
| if len(s.i) > 0 { |
| // don't generate tests for shifts by signed integers |
| if o.name == "lsh" || o.name == "rsh" { |
| continue |
| } |
| for _, i := range s.i { |
| fd.Number = fmt.Sprintf("%d", i) |
| fd.FNumber = strings.Replace(fd.Number, "-", "Neg", -1) |
| |
| // avoid division by zero |
| if o.name != "mod" && o.name != "div" || i != 0 { |
| fncCnst1.Execute(w, fd) |
| } |
| fncCnst2.Execute(w, fd) |
| } |
| } |
| } |
| } |
| |
| vrf1 := template.Must(template.New("vrf1").Parse(` |
| test_{{.Size}}{fn: {{.Name}}_{{.FNumber}}_{{.Type_}}, fnname: "{{.Name}}_{{.FNumber}}_{{.Type_}}", in: {{.Input}}, want: {{.Ans}}},`)) |
| |
| vrf2 := template.Must(template.New("vrf2").Parse(` |
| test_{{.Size}}{fn: {{.Name}}_{{.Type_}}_{{.FNumber}}, fnname: "{{.Name}}_{{.Type_}}_{{.FNumber}}", in: {{.Input}}, want: {{.Ans}}},`)) |
| |
| type cfncData struct { |
| Size, Name, Type_, Symbol, FNumber, Number string |
| Ans, Input string |
| } |
| for _, s := range szs { |
| fmt.Fprintf(w, ` |
| type test_%[1]s%[2]s struct { |
| fn func (%[1]s) %[1]s |
| fnname string |
| in %[1]s |
| want %[1]s |
| } |
| `, s.name, s.oponly) |
| fmt.Fprintf(w, "var tests_%[1]s%[2]s =[]test_%[1]s {\n\n", s.name, s.oponly) |
| |
| if len(s.u) > 0 { |
| for _, o := range ops { |
| if s.oponly != "" && s.oponly != o.name { |
| continue |
| } |
| fd := cfncData{s.name, o.name, s.name, o.symbol, "", "", "", ""} |
| for _, i := range s.u { |
| fd.Number = fmt.Sprintf("%d", i) |
| fd.FNumber = strings.Replace(fd.Number, "-", "Neg", -1) |
| |
| // unsigned |
| for _, j := range s.u { |
| |
| if o.name != "mod" && o.name != "div" || j != 0 { |
| fd.Ans = ansU(i, j, s.name, o.symbol) |
| fd.Input = fmt.Sprintf("%d", j) |
| if err := vrf1.Execute(w, fd); err != nil { |
| panic(err) |
| } |
| } |
| |
| if o.name != "mod" && o.name != "div" || i != 0 { |
| fd.Ans = ansU(j, i, s.name, o.symbol) |
| fd.Input = fmt.Sprintf("%d", j) |
| if err := vrf2.Execute(w, fd); err != nil { |
| panic(err) |
| } |
| } |
| |
| } |
| } |
| |
| } |
| } |
| |
| // signed |
| if len(s.i) > 0 { |
| for _, o := range ops { |
| if s.oponly != "" && s.oponly != o.name { |
| continue |
| } |
| // don't generate tests for shifts by signed integers |
| if o.name == "lsh" || o.name == "rsh" { |
| continue |
| } |
| fd := cfncData{s.name, o.name, s.name, o.symbol, "", "", "", ""} |
| for _, i := range s.i { |
| fd.Number = fmt.Sprintf("%d", i) |
| fd.FNumber = strings.Replace(fd.Number, "-", "Neg", -1) |
| for _, j := range s.i { |
| if o.name != "mod" && o.name != "div" || j != 0 { |
| fd.Ans = ansS(i, j, s.name, o.symbol) |
| fd.Input = fmt.Sprintf("%d", j) |
| if err := vrf1.Execute(w, fd); err != nil { |
| panic(err) |
| } |
| } |
| |
| if o.name != "mod" && o.name != "div" || i != 0 { |
| fd.Ans = ansS(j, i, s.name, o.symbol) |
| fd.Input = fmt.Sprintf("%d", j) |
| if err := vrf2.Execute(w, fd); err != nil { |
| panic(err) |
| } |
| } |
| |
| } |
| } |
| |
| } |
| } |
| |
| fmt.Fprintf(w, "}\n\n") |
| } |
| |
| fmt.Fprint(w, ` |
| |
| // TestArithmeticConst tests results for arithmetic operations against constants. |
| func TestArithmeticConst(t *testing.T) { |
| `) |
| |
| for _, s := range szs { |
| fmt.Fprintf(w, `for _, test := range tests_%s%s {`, s.name, s.oponly) |
| // Use WriteString here to avoid a vet warning about formatting directives. |
| w.WriteString(`if got := test.fn(test.in); got != test.want { |
| t.Errorf("%s(%d) = %d, want %d\n", test.fnname, test.in, got, test.want) |
| } |
| } |
| `) |
| } |
| |
| fmt.Fprint(w, ` |
| } |
| `) |
| |
| // gofmt result |
| b := w.Bytes() |
| src, err := format.Source(b) |
| if err != nil { |
| fmt.Printf("%s\n", b) |
| panic(err) |
| } |
| |
| // write to file |
| err = ioutil.WriteFile("../arithConst_test.go", src, 0666) |
| if err != nil { |
| log.Fatalf("can't write output: %v\n", err) |
| } |
| } |
