diff --git a/sqlite3.go b/sqlite3.go
index d3afff5..b566d92 100644
--- a/sqlite3.go
+++ b/sqlite3.go
@@ -284,11 +284,11 @@ func (rc *SQLiteRows) Next(dest []driver.Value) error {
 		switch C.sqlite3_column_type(rc.s.s, C.int(i)) {
 		case C.SQLITE_INTEGER:
 			val := int64(C.sqlite3_column_int64(rc.s.s, C.int(i)))
-			switch rc.decltype[i]{
+			switch rc.decltype[i] {
 			case "timestamp":
 				dest[i] = time.Unix(val, 0)
 			case "boolean":
-				dest[i] = val>0
+				dest[i] = val > 0
 			default:
 				dest[i] = val
 			}
diff --git a/sqlite3_test.go b/sqlite3_test.go
index 6c689a1..2e381ca 100644
--- a/sqlite3_test.go
+++ b/sqlite3_test.go
@@ -11,7 +11,7 @@ import (
 func TestOpen(t *testing.T) {
 	db, err := sql.Open("sqlite3", "./foo.db")
 	if err != nil {
-		t.Errorf("Failed to open database:", err)
+		t.Error("Failed to open database:", err)
 		return
 	}
 	defer os.Remove("./foo.db")
@@ -19,19 +19,19 @@ func TestOpen(t *testing.T) {
 	_, err = db.Exec("drop table foo")
 	_, err = db.Exec("create table foo (id integer)")
 	if err != nil {
-		t.Errorf("Failed to create table:", err)
+		t.Error("Failed to create table:", err)
 		return
 	}
 
 	if stat, err := os.Stat("./foo.db"); err != nil || stat.IsDir() {
-		t.Errorf("Failed to create ./foo.db")
+		t.Error("Failed to create ./foo.db")
 	}
 }
 
 func TestInsert(t *testing.T) {
 	db, err := sql.Open("sqlite3", "./foo.db")
 	if err != nil {
-		t.Errorf("Failed to open database:", err)
+		t.Error("Failed to open database:", err)
 		return
 	}
 	defer os.Remove("./foo.db")
@@ -39,13 +39,13 @@ func TestInsert(t *testing.T) {
 	_, err = db.Exec("drop table foo")
 	_, err = db.Exec("create table foo (id integer)")
 	if err != nil {
-		t.Errorf("Failed to create table:", err)
+		t.Error("Failed to create table:", err)
 		return
 	}
 
 	res, err := db.Exec("insert into foo(id) values(123)")
 	if err != nil {
-		t.Errorf("Failed to insert record:", err)
+		t.Error("Failed to insert record:", err)
 		return
 	}
 	affected, _ := res.RowsAffected()
@@ -56,7 +56,7 @@ func TestInsert(t *testing.T) {
 
 	rows, err := db.Query("select id from foo")
 	if err != nil {
-		t.Errorf("Failed to select records:", err)
+		t.Error("Failed to select records:", err)
 		return
 	}
 	defer rows.Close()
@@ -73,7 +73,7 @@ func TestInsert(t *testing.T) {
 func TestUpdate(t *testing.T) {
 	db, err := sql.Open("sqlite3", "./foo.db")
 	if err != nil {
-		t.Errorf("Failed to open database:", err)
+		t.Error("Failed to open database:", err)
 		return
 	}
 	defer os.Remove("./foo.db")
@@ -81,23 +81,23 @@ func TestUpdate(t *testing.T) {
 	_, err = db.Exec("drop table foo")
 	_, err = db.Exec("create table foo (id integer)")
 	if err != nil {
-		t.Errorf("Failed to create table:", err)
+		t.Error("Failed to create table:", err)
 		return
 	}
 
 	res, err := db.Exec("insert into foo(id) values(123)")
 	if err != nil {
-		t.Errorf("Failed to insert record:", err)
+		t.Error("Failed to insert record:", err)
 		return
 	}
 	expected, err := res.LastInsertId()
 	if err != nil {
-		t.Errorf("Failed to get LastInsertId:", err)
+		t.Error("Failed to get LastInsertId:", err)
 		return
 	}
 	affected, _ := res.RowsAffected()
 	if err != nil {
-		t.Errorf("Failed to get RowsAffected:", err)
+		t.Error("Failed to get RowsAffected:", err)
 		return
 	}
 	if affected != 1 {
@@ -107,12 +107,12 @@ func TestUpdate(t *testing.T) {
 
 	res, err = db.Exec("update foo set id = 234")
 	if err != nil {
-		t.Errorf("Failed to update record:", err)
+		t.Error("Failed to update record:", err)
 		return
 	}
 	lastId, err := res.LastInsertId()
 	if err != nil {
-		t.Errorf("Failed to get LastInsertId:", err)
+		t.Error("Failed to get LastInsertId:", err)
 		return
 	}
 	if expected != lastId {
@@ -120,7 +120,7 @@ func TestUpdate(t *testing.T) {
 	}
 	affected, _ = res.RowsAffected()
 	if err != nil {
-		t.Errorf("Failed to get RowsAffected:", err)
+		t.Error("Failed to get RowsAffected:", err)
 		return
 	}
 	if affected != 1 {
@@ -130,7 +130,7 @@ func TestUpdate(t *testing.T) {
 
 	rows, err := db.Query("select id from foo")
 	if err != nil {
-		t.Errorf("Failed to select records:", err)
+		t.Error("Failed to select records:", err)
 		return
 	}
 	defer rows.Close()
@@ -147,7 +147,7 @@ func TestUpdate(t *testing.T) {
 func TestDelete(t *testing.T) {
 	db, err := sql.Open("sqlite3", "./foo.db")
 	if err != nil {
-		t.Errorf("Failed to select records:", err)
+		t.Error("Failed to select records:", err)
 		return
 	}
 	defer os.Remove("./foo.db")
@@ -155,23 +155,23 @@ func TestDelete(t *testing.T) {
 	_, err = db.Exec("drop table foo")
 	_, err = db.Exec("create table foo (id integer)")
 	if err != nil {
-		t.Errorf("Failed to create table:", err)
+		t.Error("Failed to create table:", err)
 		return
 	}
 
 	res, err := db.Exec("insert into foo(id) values(123)")
 	if err != nil {
-		t.Errorf("Failed to insert record:", err)
+		t.Error("Failed to insert record:", err)
 		return
 	}
 	expected, err := res.LastInsertId()
 	if err != nil {
-		t.Errorf("Failed to get LastInsertId:", err)
+		t.Error("Failed to get LastInsertId:", err)
 		return
 	}
 	affected, err := res.RowsAffected()
 	if err != nil {
-		t.Errorf("Failed to get RowsAffected:", err)
+		t.Error("Failed to get RowsAffected:", err)
 		return
 	}
 	if affected != 1 {
@@ -180,12 +180,12 @@ func TestDelete(t *testing.T) {
 
 	res, err = db.Exec("delete from foo where id = 123")
 	if err != nil {
-		t.Errorf("Failed to delete record:", err)
+		t.Error("Failed to delete record:", err)
 		return
 	}
 	lastId, err := res.LastInsertId()
 	if err != nil {
-		t.Errorf("Failed to get LastInsertId:", err)
+		t.Error("Failed to get LastInsertId:", err)
 		return
 	}
 	if expected != lastId {
@@ -193,7 +193,7 @@ func TestDelete(t *testing.T) {
 	}
 	affected, err = res.RowsAffected()
 	if err != nil {
-		t.Errorf("Failed to get RowsAffected:", err)
+		t.Error("Failed to get RowsAffected:", err)
 		return
 	}
 	if affected != 1 {
@@ -202,20 +202,20 @@ func TestDelete(t *testing.T) {
 
 	rows, err := db.Query("select id from foo")
 	if err != nil {
-		t.Errorf("Failed to select records:", err)
+		t.Error("Failed to select records:", err)
 		return
 	}
 	defer rows.Close()
 
 	if rows.Next() {
-		t.Errorf("Fetched row but expected not rows")
+		t.Error("Fetched row but expected not rows")
 	}
 }
 
 func TestBooleanRoundtrip(t *testing.T) {
 	db, err := sql.Open("sqlite3", "./foo.db")
 	if err != nil {
-		t.Errorf("Failed to open database:", err)
+		t.Error("Failed to open database:", err)
 		return
 	}
 	defer os.Remove("./foo.db")
@@ -223,25 +223,25 @@ func TestBooleanRoundtrip(t *testing.T) {
 	_, err = db.Exec("DROP TABLE foo")
 	_, err = db.Exec("CREATE TABLE foo(id INTEGER, value BOOL)")
 	if err != nil {
-		t.Errorf("Failed to create table:", err)
+		t.Error("Failed to create table:", err)
 		return
 	}
 
 	_, err = db.Exec("INSERT INTO foo(id, value) VALUES(1, ?)", true)
 	if err != nil {
-		t.Errorf("Failed to insert true value:", err)
+		t.Error("Failed to insert true value:", err)
 		return
 	}
 
 	_, err = db.Exec("INSERT INTO foo(id, value) VALUES(2, ?)", false)
 	if err != nil {
-		t.Errorf("Failed to insert false value:", err)
+		t.Error("Failed to insert false value:", err)
 		return
 	}
 
 	rows, err := db.Query("SELECT id, value FROM foo")
 	if err != nil {
-		t.Errorf("Unable to query foo table:", err)
+		t.Error("Unable to query foo table:", err)
 		return
 	}
 
@@ -250,15 +250,15 @@ func TestBooleanRoundtrip(t *testing.T) {
 		var value bool
 
 		if err := rows.Scan(&id, &value); err != nil {
-			t.Errorf("Unable to scan results:", err)
+			t.Error("Unable to scan results:", err)
 			continue
 		}
 
 		if id == 1 && !value {
-			t.Errorf("Value for id 1 should be true, not false")
+			t.Error("Value for id 1 should be true, not false")
 
 		} else if id == 2 && value {
-			t.Errorf("Value for id 2 should be false, not true")
+			t.Error("Value for id 2 should be false, not true")
 		}
 	}
 }
@@ -266,7 +266,7 @@ func TestBooleanRoundtrip(t *testing.T) {
 func TestTimestamp(t *testing.T) {
 	db, err := sql.Open("sqlite3", "./foo.db")
 	if err != nil {
-		t.Errorf("Failed to open database:", err)
+		t.Error("Failed to open database:", err)
 		return
 	}
 	defer os.Remove("./foo.db")
@@ -274,33 +274,33 @@ func TestTimestamp(t *testing.T) {
 	_, err = db.Exec("DROP TABLE foo")
 	_, err = db.Exec("CREATE TABLE foo(id INTEGER, ts timeSTAMP)")
 	if err != nil {
-		t.Errorf("Failed to create table:", err)
+		t.Error("Failed to create table:", err)
 		return
 	}
 
 	timestamp1 := time.Date(2012, time.April, 6, 22, 50, 0, 0, time.UTC)
 	_, err = db.Exec("INSERT INTO foo(id, ts) VALUES(1, ?)", timestamp1)
 	if err != nil {
-		t.Errorf("Failed to insert timestamp:", err)
+		t.Error("Failed to insert timestamp:", err)
 		return
 	}
 
 	timestamp2 := time.Date(2012, time.April, 6, 23, 22, 0, 0, time.UTC)
 	_, err = db.Exec("INSERT INTO foo(id, ts) VALUES(2, ?)", timestamp2.Unix())
 	if err != nil {
-		t.Errorf("Failed to insert timestamp:", err)
+		t.Error("Failed to insert timestamp:", err)
 		return
 	}
 
 	_, err = db.Exec("INSERT INTO foo(id, ts) VALUES(3, ?)", "nonsense")
 	if err != nil {
-		t.Errorf("Failed to insert nonsense:", err)
+		t.Error("Failed to insert nonsense:", err)
 		return
 	}
 
 	rows, err := db.Query("SELECT id, ts FROM foo ORDER BY id ASC")
 	if err != nil {
-		t.Errorf("Unable to query foo table:", err)
+		t.Error("Unable to query foo table:", err)
 		return
 	}
 
@@ -310,7 +310,7 @@ func TestTimestamp(t *testing.T) {
 		var ts time.Time
 
 		if err := rows.Scan(&id, &ts); err != nil {
-			t.Errorf("Unable to scan results:", err)
+			t.Error("Unable to scan results:", err)
 			continue
 		}
 
@@ -330,119 +330,116 @@ func TestTimestamp(t *testing.T) {
 	}
 
 	if seen != 2 {
-		t.Errorf("Expected to see two valid timestamps")
+		t.Error("Expected to see two valid timestamps")
 	}
 
 	// make sure "nonsense" triggered an error
 	err = rows.Err()
 	if err == nil || !strings.Contains(err.Error(), "cannot parse \"nonsense\"") {
-		t.Errorf("Expected error from \"nonsense\" timestamp")
+		t.Error("Expected error from \"nonsense\" timestamp")
 	}
 }
 
-
 func TestBoolean(t *testing.T) {
 	db, err := sql.Open("sqlite3", "./foo.db")
 	if err != nil {
-		t.Errorf("Failed to open database:", err)
+		t.Error("Failed to open database:", err)
 		return
 	}
-	
+
 	defer os.Remove("./foo.db")
 
 	_, err = db.Exec("CREATE TABLE foo(id INTEGER, fbool BOOLEAN)")
 	if err != nil {
-		t.Errorf("Failed to create table:", err)
+		t.Error("Failed to create table:", err)
 		return
 	}
-	
+
 	bool1 := true
 	_, err = db.Exec("INSERT INTO foo(id, fbool) VALUES(1, ?)", bool1)
 	if err != nil {
-		t.Errorf("Failed to insert boolean:", err)
+		t.Error("Failed to insert boolean:", err)
 		return
 	}
 
 	bool2 := false
 	_, err = db.Exec("INSERT INTO foo(id, fbool) VALUES(2, ?)", bool2)
 	if err != nil {
-		t.Errorf("Failed to insert boolean:", err)
+		t.Error("Failed to insert boolean:", err)
 		return
 	}
 
 	bool3 := "nonsense"
 	_, err = db.Exec("INSERT INTO foo(id, fbool) VALUES(3, ?)", bool3)
 	if err != nil {
-		t.Errorf("Failed to insert nonsense:", err)
+		t.Error("Failed to insert nonsense:", err)
 		return
 	}
 
 	rows, err := db.Query("SELECT id, fbool FROM foo where fbool is ?", bool1)
 	if err != nil {
-		t.Errorf("Unable to query foo table:", err)
+		t.Error("Unable to query foo table:", err)
 		return
 	}
 	counter := 0
-	
+
 	var id int
 	var fbool bool
-	
-	for rows.Next(){
+
+	for rows.Next() {
 		if err := rows.Scan(&id, &fbool); err != nil {
-			t.Errorf("Unable to scan results:", err)
-			return 
+			t.Error("Unable to scan results:", err)
+			return
 		}
-		counter ++
+		counter++
 	}
-			
-	if counter != 1{
+
+	if counter != 1 {
 		t.Errorf("Expected 1 row but %v", counter)
-		return 	
+		return
 	}
-	
-	if id!=1 && fbool != true {
+
+	if id != 1 && fbool != true {
 		t.Errorf("Value for id 1 should be %v, not %v", bool1, fbool)
 		return
-	} 
-	
-				
+	}
+
 	rows, err = db.Query("SELECT id, fbool FROM foo where fbool is ?", bool2)
 	if err != nil {
-		t.Errorf("Unable to query foo table:", err)
+		t.Error("Unable to query foo table:", err)
 		return
 	}
-	
+
 	counter = 0
 
-	for rows.Next(){
+	for rows.Next() {
 		if err := rows.Scan(&id, &fbool); err != nil {
-			t.Errorf("Unable to scan results:", err)
-			return 
+			t.Error("Unable to scan results:", err)
+			return
 		}
-		counter ++
+		counter++
 	}
-			
-	if counter != 1{
+
+	if counter != 1 {
 		t.Errorf("Expected 1 row but %v", counter)
-		return 	
+		return
 	}
-	
+
 	if id != 2 && fbool != false {
 		t.Errorf("Value for id 2 should be %v, not %v", bool2, fbool)
 		return
 	}
-	
 
 	// make sure "nonsense" triggered an error
 	rows, err = db.Query("SELECT id, fbool FROM foo where id=?;", 3)
 	if err != nil {
-		t.Errorf("Unable to query foo table:", err)
+		t.Error("Unable to query foo table:", err)
 		return
 	}
 
 	rows.Next()
 	err = rows.Scan(&id, &fbool)
 	if err == nil {
-		t.Errorf("Expected error from \"nonsense\" bool")
+		t.Error("Expected error from \"nonsense\" bool")
 	}
-}
\ No newline at end of file
+}