Update tests according to Go style guide.

busy_test.go

@@ -28,11 +28,11 @@ func TestInterrupt(t *testing.T) {
 		return
 	})
 	if err == nil {
-		t.Fatalf("Expected interrupt but got %v", err)
+		t.Fatalf("got %v; want interrupt", err)
 	}
 	//println(err.Error())
 	if se, ok := err.(*StmtError); !ok || se.Code() != ErrInterrupt {
-		t.Errorf("Expected interrupt but got %#v", err)
+		t.Errorf("got %#v; want interrupt", err)
 	}
 }
 
@@ -56,10 +56,10 @@ func TestDefaultBusy(t *testing.T) {
 
 	_, err := db2.SchemaVersion("")
 	if err == nil {
-		t.Fatalf("Expected lock but got %v", err)
+		t.Fatalf("got %v; want lock", err)
 	}
 	if se, ok := err.(*StmtError); !ok || se.Code() != ErrBusy {
-		t.Fatalf("Exepted lock but got %#v", err)
+		t.Fatalf("got %#v; want lock", err)
 	}
 }
 

cache_test.go

@@ -5,13 +5,13 @@
 package sqlite_test
 
 import (
-	. "github.com/gwenn/gosqlite"
 	"testing"
+	. "github.com/gwenn/gosqlite"
 )
 
 func checkCacheSize(t *testing.T, db *Conn, expectedSize, expectedMaxSize int) {
 	if size, maxSize := db.CacheSize(); size != expectedSize || maxSize != expectedMaxSize {
-		t.Errorf("%d <> %d || %d <> %d", expectedSize, size, expectedMaxSize, maxSize)
+		t.Errorf("got size: %d; want %d or got maxsize: %d; want %d", size, expectedSize, maxSize, expectedMaxSize)
 	}
 }
 
@@ -74,7 +74,7 @@ func BenchmarkDisabledCache(b *testing.B) {
 	}
 
 	if size, maxSize := db.CacheSize(); size != 0 || maxSize != 0 {
-		b.Errorf("%d <> %d || %d <> %d", 0, size, 0, maxSize)
+		b.Errorf("got size: %d; want %d or got maxsize: %d; want %d", size, 0, maxSize, 0)
 	}
 }
 
@@ -90,6 +90,6 @@ func BenchmarkEnabledCache(b *testing.B) {
 	}
 
 	if size, maxSize := db.CacheSize(); size != 1 || maxSize != 10 {
-		b.Errorf("%d <> %d || %d <> %d", 1, size, 10, maxSize)
+		b.Errorf("got size: %d; want %d or got maxsize: %d; want %d", size, 1, maxSize, 10)
 	}
 }

date_test.go

@@ -15,12 +15,12 @@ import (
 func TestJulianDay(t *testing.T) {
 	utc := JulianDayToUTC(2440587.5)
 	if utc.Unix() != 0 {
-		t.Errorf("Error, expecting %d got %d", 0, utc.Unix())
+		t.Errorf("got %d; want %d ", utc.Unix(), 0)
 	}
 	now := time.Now()
 	r := JulianDayToLocalTime(JulianDay(now))
 	if r.Unix() != now.Unix() { // FIXME Rounding problem?
-		t.Errorf("%#v <> %#v", now, r)
+		t.Errorf("got %#v; want %#v", r, now)
 	}
 }
 
@@ -114,7 +114,7 @@ func TestBindTimeAsString(t *testing.T) {
 	err = db.OneValue("SELECT /*datetime(*/time/*)*/ FROM test where ROWID = ?", &tim, id2)
 	checkNoError(t, err, "error selecting TimeStamp: %s")
 	if !now.Equal(tim) {
-		t.Errorf("TimeStamp: %s vs %s", now, tim)
+		t.Errorf("got timeStamp: %s; want %s", tim, now)
 	}
 }
 

driver_test.go

@@ -168,7 +168,7 @@ func TestRowsWithStmtClosed(t *testing.T) {
 func TestUnwrap(t *testing.T) {
 	db := sqlOpen(t)
 	conn := sqlite.Unwrap(db)
-	assert.Tf(t, conn != nil, "Expecting *sqlite.Conn but got %#v", conn)
+	assert.Tf(t, conn != nil, "got %#v; want *sqlite.Conn", conn)
 	// fmt.Printf("%#v\n", conn)
 	conn.TotalChanges()
 }

limit_test.go

@@ -18,8 +18,8 @@ func TestLimit(t *testing.T) {
 	limitVariableNumber := db.Limit(LimitVariableNumber)
 	assert.Tf(t, limitVariableNumber < 1e6, "unexpected value for LimitVariableNumber: %d", limitVariableNumber)
 	oldLimitVariableNumber := db.SetLimit(LimitVariableNumber, 99)
-	assert.Equalf(t, limitVariableNumber, oldLimitVariableNumber, "unexpected value for LimitVariableNumber: %d <> %d", limitVariableNumber, oldLimitVariableNumber)
+	assert.Equalf(t, limitVariableNumber, oldLimitVariableNumber, "got LimitVariableNumber: %d; want %d", oldLimitVariableNumber, limitVariableNumber)
 	limitVariableNumber = db.Limit(LimitVariableNumber)
-	assert.Equalf(t, int32(99), limitVariableNumber, "unexpected value for LimitVariableNumber: %d <> %d", 99, limitVariableNumber)
+	assert.Equalf(t, int32(99), limitVariableNumber, "got LimitVariableNumber: %d; want %d", limitVariableNumber, 99)
 
 }

meta_test.go

@@ -24,7 +24,7 @@ func TestDatabases(t *testing.T) {
 	databases, err := db.Databases()
 	checkNoError(t, err, "error looking for databases: %s")
 	if len(databases) != 1 {
-		t.Errorf("Expected one database but got %d\n", len(databases))
+		t.Errorf("got %d database(s); want one", len(databases))
 	}
 	if _, ok := databases["main"]; !ok {
 		t.Errorf("Expected 'main' database\n")
@@ -86,7 +86,7 @@ func TestColumns(t *testing.T) {
 	columns, err := db.Columns("", "test")
 	checkNoError(t, err, "error listing columns: %s")
 	if len(columns) != 4 {
-		t.Fatalf("Expected 4 columns <> %d", len(columns))
+		t.Fatalf("got %d columns; want 4", len(columns))
 	}
 	column := columns[2]
 	assert.Equal(t, "int_num", column.Name, "column name")
@@ -121,7 +121,7 @@ func TestForeignKeys(t *testing.T) {
 	fks, err := db.ForeignKeys("", "child")
 	checkNoError(t, err, "error listing FKs: %s")
 	if len(fks) != 1 {
-		t.Fatalf("expected 1 FK <> %d", len(fks))
+		t.Fatalf("got %d FK(s); want 1", len(fks))
 	}
 	fk := fks[0]
 	if fk.From[0] != "parentId" || fk.Table != "parent" || fk.To[0] != "id" {
@@ -138,7 +138,7 @@ func TestTableIndexes(t *testing.T) {
 	indexes, err := db.TableIndexes("", "test")
 	checkNoError(t, err, "error listing indexes: %s")
 	if len(indexes) != 1 {
-		t.Fatalf("Expected one index <> %d", len(indexes))
+		t.Fatalf("got %d index(es); want one", len(indexes))
 	}
 	index := indexes[0]
 	assert.Equal(t, "test_index", index.Name, "index name")
@@ -147,7 +147,7 @@ func TestTableIndexes(t *testing.T) {
 	columns, err := db.IndexColumns("", "test_index")
 	checkNoError(t, err, "error listing index columns: %s")
 	if len(columns) != 1 {
-		t.Fatalf("expected one column <> %d", len(columns))
+		t.Fatalf("got %d column(s); want one", len(columns))
 	}
 	column := columns[0]
 	assert.Equal(t, "a_string", column.Name, "column name")

sqlite_test.go

@@ -203,7 +203,7 @@ func TestConnExecWithSelect(t *testing.T) {
 	if serr, ok := err.(*StmtError); ok {
 		assert.Equal(t, ErrSpecific, serr.Code())
 	} else {
-		t.Errorf("Expected StmtError but got %s", reflect.TypeOf(err))
+		t.Errorf("got %s; want StmtError", reflect.TypeOf(err))
 	}
 }
 

stmt_test.go

@@ -158,7 +158,7 @@ func TestScanCheck(t *testing.T) {
 		assert.Equal(t, ErrSpecific, serr.Code())
 		assert.Equal(t, s.SQL(), serr.SQL())
 	} else {
-		t.Errorf("Expected StmtError but got %s", reflect.TypeOf(err))
+		t.Errorf("got %s; want StmtError", reflect.TypeOf(err))
 	}
 }
 
@@ -276,7 +276,7 @@ func TestStmtExecWithSelect(t *testing.T) {
 	if serr, ok := err.(*StmtError); ok {
 		assert.Equal(t, ErrSpecific, serr.Code())
 	} else {
-		t.Errorf("Expected StmtError but got %s", reflect.TypeOf(err))
+		t.Errorf("got %s; want StmtError", reflect.TypeOf(err))
 	}
 }
 
@@ -296,7 +296,7 @@ func TestStmtSelectWithInsert(t *testing.T) {
 	if serr, ok := err.(*StmtError); ok {
 		assert.Equal(t, ErrSpecific, serr.Code())
 	} else {
-		t.Errorf("Expected StmtError but got %s", reflect.TypeOf(err))
+		t.Errorf("got %s; want StmtError", reflect.TypeOf(err))
 	}
 	assert.T(t, !exists, "false expected")
 }

vtab_test.go

@@ -115,7 +115,7 @@ func TestCreateModule(t *testing.T) {
 		if err = s.Scan(&i, &value); err != nil {
 			return
 		}
-		assert.Equal(t, intarray[i], value, "Expected '%d' but got '%d'")
+		assert.Equalf(t, intarray[i], value, "got '%d'; want '%d'", value, intarray[i])
 		return
 	})
 	checkNoError(t, err, "couldn't select from virtual table: %s")