update uses of gotest.
minor tweak to testing structure for protobuf.
R=rsc
DELTA=276 (71 added, 75 deleted, 130 changed)
OCL=19614
CL=19621
import (
"fmt";
"os";
- "strconv"
+ "strconv";
+ "testing"
)
type Test struct {
Test{ ".e-1", "0", os.EINVAL },
}
-func XTestAtof(opt bool) bool {
+func XTestAtof(t *testing.T, opt bool) {
oldopt := strconv.optimize;
strconv.optimize = opt;
- ok := true;
for i := 0; i < len(tests); i++ {
- t := &tests[i];
- out, err := strconv.atof64(t.in);
+ test := &tests[i];
+ out, err := strconv.atof64(test.in);
outs := strconv.ftoa64(out, 'g', -1);
- if outs != t.out || err != t.err {
- fmt.printf("strconv.atof64(%v) = %v, %v want %v, %v\n",
- t.in, out, err, t.out, t.err);
- ok = false;
+ if outs != test.out || err != test.err {
+ t.Errorf("strconv.atof64(%v) = %v, %v want %v, %v\n",
+ test.in, out, err, test.out, test.err);
}
if float64(float32(out)) == out {
- out32, err := strconv.atof32(t.in);
+ out32, err := strconv.atof32(test.in);
outs := strconv.ftoa32(out32, 'g', -1);
- if outs != t.out || err != t.err {
- fmt.printf("strconv.atof32(%v) = %v, %v want %v, %v # %v\n",
- t.in, out32, err, t.out, t.err, out);
- ok = false;
+ if outs != test.out || err != test.err {
+ t.Errorf("strconv.atof32(%v) = %v, %v want %v, %v # %v\n",
+ test.in, out32, err, test.out, test.err, out);
}
}
if floatsize == 64 || float64(float32(out)) == out {
- outf, err := strconv.atof(t.in);
+ outf, err := strconv.atof(test.in);
outs := strconv.ftoa(outf, 'g', -1);
- if outs != t.out || err != t.err {
- fmt.printf("strconv.ftoa(%v) = %v, %v want %v, %v # %v\n",
- t.in, outf, err, t.out, t.err, out);
- ok = false;
+ if outs != test.out || err != test.err {
+ t.Errorf("strconv.ftoa(%v) = %v, %v want %v, %v # %v\n",
+ test.in, outf, err, test.out, test.err, out);
}
}
}
strconv.optimize = oldopt;
- return ok;
}
-export func TestAtof() bool {
- return XTestAtof(true);
+export func TestAtof(t *testing.T) {
+ XTestAtof(t, true);
}
-export func TestAtofSlow() bool {
- return XTestAtof(false);
+export func TestAtofSlow(t *testing.T) {
+ XTestAtof(t, false);
}
import (
"os";
"fmt";
- "strconv"
+ "strconv";
+ "testing"
)
type Uint64Test struct {
Int32Test{ "-2147483649", -1<<31, os.ERANGE },
}
-export func TestAtoui64() bool {
- ok := true;
+export func TestAtoui64(t *testing.T) {
for i := 0; i < len(uint64tests); i++ {
- t := &uint64tests[i];
- out, err := strconv.atoui64(t.in);
- if t.out != out || t.err != err {
- fmt.printf("strconv.atoui64(%v) = %v, %v want %v, %v\n",
- t.in, out, err, t.out, t.err);
- ok = false;
+ test := &uint64tests[i];
+ out, err := strconv.atoui64(test.in);
+ if test.out != out || test.err != err {
+ t.Errorf("strconv.atoui64(%v) = %v, %v want %v, %v\n",
+ test.in, out, err, test.out, test.err);
}
}
- return ok;
}
-export func TestAtoi64() bool {
- ok := true;
+export func TestAtoi64(t *testing.T) {
for i := 0; i < len(int64tests); i++ {
- t := &int64tests[i];
- out, err := strconv.atoi64(t.in);
- if t.out != out || t.err != err {
- fmt.printf("strconv.atoi64(%v) = %v, %v want %v, %v\n",
- t.in, out, err, t.out, t.err);
- ok = false;
+ test := &int64tests[i];
+ out, err := strconv.atoi64(test.in);
+ if test.out != out || test.err != err {
+ t.Errorf("strconv.atoi64(%v) = %v, %v want %v, %v\n",
+ test.in, out, err, test.out, test.err);
}
}
- return ok;
}
func IntSize1() uint {
if tmp<<16<<16 == 0 {
return 32;
}
-println("tmp<<32 = ", tmp<<32);
return 64;
}
-export func TestAtoui() bool {
- ok := true;
+export func TestAtoui(t *testing.T) {
switch IntSize1() {
case 32:
for i := 0; i < len(uint32tests); i++ {
- t := &uint32tests[i];
- out, err := strconv.atoui(t.in);
- if t.out != uint32(out) || t.err != err {
- fmt.printf("strconv.atoui(%v) = %v, %v want %v, %v\n",
- t.in, out, err, t.out, t.err);
- ok = false;
+ test := &uint32tests[i];
+ out, err := strconv.atoui(test.in);
+ if test.out != uint32(out) || test.err != err {
+ t.Errorf("strconv.atoui(%v) = %v, %v want %v, %v\n",
+ test.in, out, err, test.out, test.err);
}
}
case 64:
for i := 0; i < len(uint64tests); i++ {
- t := &uint64tests[i];
- out, err := strconv.atoui(t.in);
- if t.out != uint64(out) || t.err != err {
- fmt.printf("strconv.atoui(%v) = %v, %v want %v, %v\n",
- t.in, out, err, t.out, t.err);
- ok = false;
+ test := &uint64tests[i];
+ out, err := strconv.atoui(test.in);
+ if test.out != uint64(out) || test.err != err {
+ t.Errorf("strconv.atoui(%v) = %v, %v want %v, %v\n",
+ test.in, out, err, test.out, test.err);
}
}
}
- return ok;
}
-export func TestAtoi() bool {
- ok := true;
+export func TestAtoi(t *testing.T) {
switch IntSize1() {
case 32:
for i := 0; i < len(int32tests); i++ {
- t := &int32tests[i];
- out, err := strconv.atoi(t.in);
- if t.out != int32(out) || t.err != err {
- fmt.printf("strconv.atoi(%v) = %v, %v want %v, %v\n",
- t.in, out, err, t.out, t.err);
- ok = false;
+ test := &int32tests[i];
+ out, err := strconv.atoi(test.in);
+ if test.out != int32(out) || test.err != err {
+ t.Errorf("strconv.atoi(%v) = %v, %v want %v, %v\n",
+ test.in, out, err, test.out, test.err);
}
}
case 64:
for i := 0; i < len(int64tests); i++ {
- t := &int64tests[i];
- out, err := strconv.atoi(t.in);
- if t.out != int64(out) || t.err != err {
- fmt.printf("strconv.atoi(%v) = %v, %v want %v, %v\n",
- t.in, out, err, t.out, t.err);
- ok = false;
+ test := &int64tests[i];
+ out, err := strconv.atoi(test.in);
+ if test.out != int64(out) || test.err != err {
+ t.Errorf("strconv.atoi(%v) = %v, %v want %v, %v\n",
+ test.in, out, err, test.out, test.err);
}
}
}
- return ok;
}
import (
"fmt";
- "strconv"
+ "strconv";
+ "testing";
)
type ShiftTest struct {
ShiftTest{ 1953125, 9, "1000000000" },
}
-export func TestDecimalShift() bool {
+export func TestDecimalShift(t *testing.T) {
ok := true;
for i := 0; i < len(shifttests); i++ {
- t := &shifttests[i];
- s := strconv.NewDecimal(t.i).Shift(t.shift).String();
- if s != t.out {
- fmt.printf("Decimal %v << %v = %v, want %v\n",
- t.i, t.shift, s, t.out);
- ok = false;
+ test := &shifttests[i];
+ s := strconv.NewDecimal(test.i).Shift(test.shift).String();
+ if s != test.out {
+ t.Errorf("Decimal %v << %v = %v, want %v\n",
+ test.i, test.shift, s, test.out);
}
}
- return ok;
}
type RoundTest struct {
RoundTest{ 12999999, 4, "12990000", "13000000", "13000000", 13000000 },
}
-export func TestDecimalRound() bool {
- ok := true;
+export func TestDecimalRound(t *testing.T) {
for i := 0; i < len(roundtests); i++ {
- t := &roundtests[i];
- s := strconv.NewDecimal(t.i).RoundDown(t.nd).String();
- if s != t.down {
- fmt.printf("Decimal %v RoundDown %d = %v, want %v\n",
- t.i, t.nd, s, t.down);
- ok = false;
+ test := &roundtests[i];
+ s := strconv.NewDecimal(test.i).RoundDown(test.nd).String();
+ if s != test.down {
+ t.Errorf("Decimal %v RoundDown %d = %v, want %v\n",
+ test.i, test.nd, s, test.down);
}
- s = strconv.NewDecimal(t.i).Round(t.nd).String();
- if s != t.round {
- fmt.printf("Decimal %v Round %d = %v, want %v\n",
- t.i, t.nd, s, t.down);
- ok = false;
+ s = strconv.NewDecimal(test.i).Round(test.nd).String();
+ if s != test.round {
+ t.Errorf("Decimal %v Round %d = %v, want %v\n",
+ test.i, test.nd, s, test.down);
}
- s = strconv.NewDecimal(t.i).RoundUp(t.nd).String();
- if s != t.up {
- fmt.printf("Decimal %v RoundUp %d = %v, want %v\n",
- t.i, t.nd, s, t.up);
- ok = false;
+ s = strconv.NewDecimal(test.i).RoundUp(test.nd).String();
+ if s != test.up {
+ t.Errorf("Decimal %v RoundUp %d = %v, want %v\n",
+ test.i, test.nd, s, test.up);
}
}
- return ok;
}
type RoundIntTest struct {
RoundIntTest{ 1000, 0, 1000 },
}
-export func TestDecimalRoundedInteger() bool {
- ok := true;
+export func TestDecimalRoundedInteger(t *testing.T) {
for i := 0; i < len(roundinttests); i++ {
- t := roundinttests[i];
+ test := roundinttests[i];
// TODO: should be able to use int := here.
- int1 := strconv.NewDecimal(t.i).Shift(t.shift).RoundedInteger();
- if int1 != t.int {
- fmt.printf("Decimal %v >> %v RoundedInteger = %v, want %v\n",
- t.i, t.shift, int1, t.int);
- ok = false;
+ int1 := strconv.NewDecimal(test.i).Shift(test.shift).RoundedInteger();
+ if int1 != test.int {
+ t.Errorf("Decimal %v >> %v RoundedInteger = %v, want %v\n",
+ test.i, test.shift, int1, test.int);
}
}
- return ok;
}
"os";
"strconv";
"strings";
+ "testing";
)
func pow2(i int) float64 {
return f1, true;
}
-export func TestFp() bool {
+export func TestFp(t *testing.T) {
fd, err := os.Open("testfp.txt", os.O_RDONLY, 0);
if err != nil {
panicln("testfp: open testfp.txt:", err.String());
}
lineno := 0;
- ok := true;
for {
line, err2 := b.ReadLineString('\n', false);
if err2 == bufio.EndOfFile {
}
a := strings.split(line, " ");
if len(a) != 4 {
- print("testfp.txt:", lineno, ": wrong field count\n");
+ t.Errorf("testfp.txt:", lineno, ": wrong field count\n");
continue;
}
var s string;
var ok bool;
v, ok = myatof64(a[2]);
if !ok {
- print("testfp.txt:", lineno, ": cannot atof64 ", a[2]);
+ t.Errorf("testfp.txt:", lineno, ": cannot atof64 ", a[2]);
continue;
}
s = fmt.sprintf(a[1], v);
case "float32":
v1, ok := myatof32(a[2]);
if !ok {
- print("testfp.txt:", lineno, ": cannot atof32 ", a[2]);
+ t.Errorf("testfp.txt:", lineno, ": cannot atof32 ", a[2]);
continue;
}
s = fmt.sprintf(a[1], v1);
v = float64(v1);
}
if s != a[3] {
- print("testfp.txt:", lineno, ": ", a[0], " ", a[1], " ", a[2], " (", v, ") ",
+ t.Errorf("testfp.txt:", lineno, ": ", a[0], " ", a[1], " ", a[2], " (", v, ") ",
"want ", a[3], " got ", s, "\n");
- ok = false;
}
//else print("testfp.txt:", lineno, ": worked! ", s, "\n");
}
- return ok;
}
// license that can be found in the LICENSE file.
package strconv
-import "strconv"
+
+import (
+ "strconv";
+ "testing"
+)
type Test struct {
f float64;
Test{ -1, 'b', -1, "-4503599627370496p-52" },
}
-export func TestFtoa() bool {
- ok := true;
+export func TestFtoa(t *testing.T) {
if strconv.floatsize != 32 {
panic("floatsize: ", strconv.floatsize);
}
for i := 0; i < len(ftests); i++ {
- t := &ftests[i];
- s := strconv.ftoa64(t.f, t.fmt, t.prec);
- if s != t.s {
- println("test", t.f, string(t.fmt), t.prec, "want", t.s, "got", s);
- ok = false;
+ test := &ftests[i];
+ s := strconv.ftoa64(test.f, test.fmt, test.prec);
+ if s != test.s {
+ t.Errorf("test", test.f, string(test.fmt), test.prec, "want", test.s, "got", s);
}
- if float64(float32(t.f)) == t.f && t.fmt != 'b' {
- s := strconv.ftoa32(float32(t.f), t.fmt, t.prec);
- if s != t.s {
- println("test32", t.f, string(t.fmt), t.prec, "want", t.s, "got", s);
- ok = false;
+ if float64(float32(test.f)) == test.f && test.fmt != 'b' {
+ s := strconv.ftoa32(float32(test.f), test.fmt, test.prec);
+ if s != test.s {
+ t.Errorf("test32", test.f, string(test.fmt), test.prec, "want", test.s, "got", s);
}
}
}
- return ok;
}
"fmt";
"os";
"strconv";
+ "testing";
)
type Int64Test struct {
Int64Test{ -1<<63, "-9223372036854775808" },
}
-export func TestItoa() bool {
- ok := true;
+export func TestItoa(t *testing.T) {
for i := 0; i < len(xint64tests); i++ {
- t := xint64tests[i];
- s := strconv.itoa64(t.in);
- if s != t.out {
- fmt.printf("strconv.itoa64(%v) = %v want %v\n",
- t.in, s, t.out);
- ok = false;
+ test := xint64tests[i];
+ s := strconv.itoa64(test.in);
+ if s != test.out {
+ t.Error("strconv.itoa64(%v) = %v want %v\n",
+ test.in, s, test.out);
}
- if int64(int(t.in)) == t.in {
- s := strconv.itoa(int(t.in));
- if s != t.out {
- fmt.printf("strconv.itoa(%v) = %v want %v\n",
- t.in, s, t.out);
- ok = false;
+ if int64(int(test.in)) == test.in {
+ s := strconv.itoa(int(test.in));
+ if s != test.out {
+ t.Error("strconv.itoa(%v) = %v want %v\n",
+ test.in, s, test.out);
}
}
}
- return ok;
}
// TODO: Use once there is a strconv.uitoa
package testing
import (
- "flag"
+ "fmt";
+ "flag";
)
var chatty bool;
flag.Bool("chatty", false, &chatty, "chatty");
}
+export type T struct {
+ errors string;
+ failed bool;
+ ch *chan *T;
+}
+
+func (t *T) Fail() {
+ t.failed = true
+}
+
+func (t *T) FailNow() {
+ t.Fail();
+ t.ch <- t;
+ sys.goexit();
+}
+
+func (t *T) Log(args ...) {
+ t.errors += "\t" + fmt.sprintln(args);
+}
+
+func (t *T) Logf(format string, args ...) {
+ t.errors += fmt.sprintf("\t" + format, args);
+ l := len(t.errors);
+ if l > 0 && t.errors[l-1] != '\n' {
+ t.errors += "\n"
+ }
+}
+
+func (t *T) Error(args ...) {
+ t.Log(args);
+ t.Fail();
+}
+
+func (t *T) Errorf(format string, args ...) {
+ t.Logf(format, args);
+ t.Fail();
+}
+
+func (t *T) Fatal(args ...) {
+ t.Log(args);
+ t.FailNow();
+}
+
+func (t *T) Fatalf(format string, args ...) {
+ t.Logf(format, args);
+ t.FailNow();
+}
+
export type Test struct {
name string;
- f *() bool;
+ f *(*T);
+}
+
+func TRunner(t *T, test *Test) {
+ test.f(t);
+ t.ch <- t;
}
export func Main(tests *[]Test) {
- flag.Parse();
ok := true;
- if len(tests) == 0 {
- println("warning: no tests available");
- } else if chatty {
- println(len(tests), "tests to run");
- }
for i := 0; i < len(tests); i++ {
if chatty {
println("=== RUN ", tests[i].name);
}
- ok1 := tests[i].f();
- if !ok1 {
+ t := new(T);
+ t.ch = new(chan *T);
+ go TRunner(t, &tests[i]);
+ <-t.ch;
+ if t.failed {
+ println("--- FAIL:", tests[i].name);
+ print(t.errors);
ok = false;
- println("--- FAIL", tests[i].name);
} else if chatty {
- println("--- PASS", tests[i].name);
+ println("--- PASS:", tests[i].name);
+ print(t.errors);
}
}
if !ok {
+ println("FAIL");
sys.exit(1);
}
println("PASS");