From 3456489fa1fb94197fcec4fc4c0de7000bf1f1be Mon Sep 17 00:00:00 2001 From: cds Date: Tue, 11 Sep 2012 08:17:09 -0500 Subject: gofmt + fix erroneous t.Errorf("foo:", err) statements to t.Error("foo:", err) . Original: --- FAIL: TestInsert (0.00 seconds) sqlite3_test.go:42: Failed to create table:%!(EXTRA *errors.errorString=unable to open database file) With corrections: --- FAIL: TestInsert (0.00 seconds) sqlite3_test.go:42: Failed to create table: unable to open database file --- sqlite3_test.go | 157 +++++++++++++++++++++++++++----------------------------- 1 file changed, 77 insertions(+), 80 deletions(-) (limited to 'sqlite3_test.go') 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 +} -- cgit v1.2.3 From 54826d95859d2b92effc75b1e13acb5aacd0e6dd Mon Sep 17 00:00:00 2001 From: cds Date: Tue, 11 Sep 2012 08:41:45 -0500 Subject: Fix erroneous error message for sql.Open() --- sqlite3_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sqlite3_test.go') diff --git a/sqlite3_test.go b/sqlite3_test.go index 2e381ca..181f59b 100644 --- a/sqlite3_test.go +++ b/sqlite3_test.go @@ -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.Error("Failed to select records:", err) + t.Error("Failed to open database:", err) return } defer os.Remove("./foo.db") -- cgit v1.2.3 From 40b65367c59385f3458b6876082478e276b4b76b Mon Sep 17 00:00:00 2001 From: cds Date: Tue, 11 Sep 2012 09:23:21 -0500 Subject: Added missing db.Close() and rows.Close() calls; fixes tests on vmhgfs filesystems. Individual tests were never successfully removing 'foo.db' (the error was ignored), which caused everything but the first test to fail on my vmhgfs filesystem. Adding the relevant defer db.Close() and rows.Close() calls fixed the leaks, enabling os.Remove() to work. --- sqlite3_test.go | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'sqlite3_test.go') diff --git a/sqlite3_test.go b/sqlite3_test.go index 181f59b..a77dd6e 100644 --- a/sqlite3_test.go +++ b/sqlite3_test.go @@ -15,6 +15,7 @@ func TestOpen(t *testing.T) { return } defer os.Remove("./foo.db") + defer db.Close() _, err = db.Exec("drop table foo") _, err = db.Exec("create table foo (id integer)") @@ -35,6 +36,7 @@ func TestInsert(t *testing.T) { return } defer os.Remove("./foo.db") + defer db.Close() _, err = db.Exec("drop table foo") _, err = db.Exec("create table foo (id integer)") @@ -77,6 +79,7 @@ func TestUpdate(t *testing.T) { return } defer os.Remove("./foo.db") + defer db.Close() _, err = db.Exec("drop table foo") _, err = db.Exec("create table foo (id integer)") @@ -151,6 +154,7 @@ func TestDelete(t *testing.T) { return } defer os.Remove("./foo.db") + defer db.Close() _, err = db.Exec("drop table foo") _, err = db.Exec("create table foo (id integer)") @@ -219,6 +223,7 @@ func TestBooleanRoundtrip(t *testing.T) { return } defer os.Remove("./foo.db") + defer db.Close() _, err = db.Exec("DROP TABLE foo") _, err = db.Exec("CREATE TABLE foo(id INTEGER, value BOOL)") @@ -244,6 +249,7 @@ func TestBooleanRoundtrip(t *testing.T) { t.Error("Unable to query foo table:", err) return } + defer rows.Close() for rows.Next() { var id int @@ -270,6 +276,7 @@ func TestTimestamp(t *testing.T) { return } defer os.Remove("./foo.db") + defer db.Close() _, err = db.Exec("DROP TABLE foo") _, err = db.Exec("CREATE TABLE foo(id INTEGER, ts timeSTAMP)") @@ -303,6 +310,7 @@ func TestTimestamp(t *testing.T) { t.Error("Unable to query foo table:", err) return } + defer rows.Close() seen := 0 for rows.Next() { @@ -348,6 +356,7 @@ func TestBoolean(t *testing.T) { } defer os.Remove("./foo.db") + defer db.Close() _, err = db.Exec("CREATE TABLE foo(id INTEGER, fbool BOOLEAN)") if err != nil { -- cgit v1.2.3 From 2a36f8cd420b159de9b282a8373053b6c6273618 Mon Sep 17 00:00:00 2001 From: cds Date: Tue, 11 Sep 2012 10:13:11 -0500 Subject: Replace t.Error(); return statement pairs with single t.Fatal() --- sqlite3_test.go | 156 +++++++++++++++++++------------------------------------- 1 file changed, 52 insertions(+), 104 deletions(-) (limited to 'sqlite3_test.go') diff --git a/sqlite3_test.go b/sqlite3_test.go index a77dd6e..da9ab4c 100644 --- a/sqlite3_test.go +++ b/sqlite3_test.go @@ -11,8 +11,7 @@ import ( func TestOpen(t *testing.T) { db, err := sql.Open("sqlite3", "./foo.db") if err != nil { - t.Error("Failed to open database:", err) - return + t.Fatal("Failed to open database:", err) } defer os.Remove("./foo.db") defer db.Close() @@ -20,8 +19,7 @@ func TestOpen(t *testing.T) { _, err = db.Exec("drop table foo") _, err = db.Exec("create table foo (id integer)") if err != nil { - t.Error("Failed to create table:", err) - return + t.Fatal("Failed to create table:", err) } if stat, err := os.Stat("./foo.db"); err != nil || stat.IsDir() { @@ -32,8 +30,7 @@ func TestOpen(t *testing.T) { func TestInsert(t *testing.T) { db, err := sql.Open("sqlite3", "./foo.db") if err != nil { - t.Error("Failed to open database:", err) - return + t.Fatal("Failed to open database:", err) } defer os.Remove("./foo.db") defer db.Close() @@ -41,25 +38,21 @@ func TestInsert(t *testing.T) { _, err = db.Exec("drop table foo") _, err = db.Exec("create table foo (id integer)") if err != nil { - t.Error("Failed to create table:", err) - return + t.Fatal("Failed to create table:", err) } res, err := db.Exec("insert into foo(id) values(123)") if err != nil { - t.Error("Failed to insert record:", err) - return + t.Fatal("Failed to insert record:", err) } affected, _ := res.RowsAffected() if affected != 1 { - t.Errorf("Expected %d for affected rows, but %d:", 1, affected) - return + t.Fatalf("Expected %d for affected rows, but %d:", 1, affected) } rows, err := db.Query("select id from foo") if err != nil { - t.Error("Failed to select records:", err) - return + t.Fatal("Failed to select records:", err) } defer rows.Close() @@ -75,8 +68,7 @@ func TestInsert(t *testing.T) { func TestUpdate(t *testing.T) { db, err := sql.Open("sqlite3", "./foo.db") if err != nil { - t.Error("Failed to open database:", err) - return + t.Fatal("Failed to open database:", err) } defer os.Remove("./foo.db") defer db.Close() @@ -84,57 +76,47 @@ func TestUpdate(t *testing.T) { _, err = db.Exec("drop table foo") _, err = db.Exec("create table foo (id integer)") if err != nil { - t.Error("Failed to create table:", err) - return + t.Fatal("Failed to create table:", err) } res, err := db.Exec("insert into foo(id) values(123)") if err != nil { - t.Error("Failed to insert record:", err) - return + t.Fatal("Failed to insert record:", err) } expected, err := res.LastInsertId() if err != nil { - t.Error("Failed to get LastInsertId:", err) - return + t.Fatal("Failed to get LastInsertId:", err) } affected, _ := res.RowsAffected() if err != nil { - t.Error("Failed to get RowsAffected:", err) - return + t.Fatal("Failed to get RowsAffected:", err) } if affected != 1 { - t.Errorf("Expected %d for affected rows, but %d:", 1, affected) - return + t.Fatalf("Expected %d for affected rows, but %d:", 1, affected) } res, err = db.Exec("update foo set id = 234") if err != nil { - t.Error("Failed to update record:", err) - return + t.Fatal("Failed to update record:", err) } lastId, err := res.LastInsertId() if err != nil { - t.Error("Failed to get LastInsertId:", err) - return + t.Fatal("Failed to get LastInsertId:", err) } if expected != lastId { t.Errorf("Expected %q for last Id, but %q:", expected, lastId) } affected, _ = res.RowsAffected() if err != nil { - t.Error("Failed to get RowsAffected:", err) - return + t.Fatal("Failed to get RowsAffected:", err) } if affected != 1 { - t.Errorf("Expected %d for affected rows, but %d:", 1, affected) - return + t.Fatalf("Expected %d for affected rows, but %d:", 1, affected) } rows, err := db.Query("select id from foo") if err != nil { - t.Error("Failed to select records:", err) - return + t.Fatal("Failed to select records:", err) } defer rows.Close() @@ -150,8 +132,7 @@ func TestUpdate(t *testing.T) { func TestDelete(t *testing.T) { db, err := sql.Open("sqlite3", "./foo.db") if err != nil { - t.Error("Failed to open database:", err) - return + t.Fatal("Failed to open database:", err) } defer os.Remove("./foo.db") defer db.Close() @@ -159,24 +140,20 @@ func TestDelete(t *testing.T) { _, err = db.Exec("drop table foo") _, err = db.Exec("create table foo (id integer)") if err != nil { - t.Error("Failed to create table:", err) - return + t.Fatal("Failed to create table:", err) } res, err := db.Exec("insert into foo(id) values(123)") if err != nil { - t.Error("Failed to insert record:", err) - return + t.Fatal("Failed to insert record:", err) } expected, err := res.LastInsertId() if err != nil { - t.Error("Failed to get LastInsertId:", err) - return + t.Fatal("Failed to get LastInsertId:", err) } affected, err := res.RowsAffected() if err != nil { - t.Error("Failed to get RowsAffected:", err) - return + t.Fatal("Failed to get RowsAffected:", err) } if affected != 1 { t.Errorf("Expected %d for cout of affected rows, but %q:", 1, affected) @@ -184,21 +161,18 @@ func TestDelete(t *testing.T) { res, err = db.Exec("delete from foo where id = 123") if err != nil { - t.Error("Failed to delete record:", err) - return + t.Fatal("Failed to delete record:", err) } lastId, err := res.LastInsertId() if err != nil { - t.Error("Failed to get LastInsertId:", err) - return + t.Fatal("Failed to get LastInsertId:", err) } if expected != lastId { t.Errorf("Expected %q for last Id, but %q:", expected, lastId) } affected, err = res.RowsAffected() if err != nil { - t.Error("Failed to get RowsAffected:", err) - return + t.Fatal("Failed to get RowsAffected:", err) } if affected != 1 { t.Errorf("Expected %d for cout of affected rows, but %q:", 1, affected) @@ -206,8 +180,7 @@ func TestDelete(t *testing.T) { rows, err := db.Query("select id from foo") if err != nil { - t.Error("Failed to select records:", err) - return + t.Fatal("Failed to select records:", err) } defer rows.Close() @@ -219,8 +192,7 @@ func TestDelete(t *testing.T) { func TestBooleanRoundtrip(t *testing.T) { db, err := sql.Open("sqlite3", "./foo.db") if err != nil { - t.Error("Failed to open database:", err) - return + t.Fatal("Failed to open database:", err) } defer os.Remove("./foo.db") defer db.Close() @@ -228,26 +200,22 @@ 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.Error("Failed to create table:", err) - return + t.Fatal("Failed to create table:", err) } _, err = db.Exec("INSERT INTO foo(id, value) VALUES(1, ?)", true) if err != nil { - t.Error("Failed to insert true value:", err) - return + t.Fatal("Failed to insert true value:", err) } _, err = db.Exec("INSERT INTO foo(id, value) VALUES(2, ?)", false) if err != nil { - t.Error("Failed to insert false value:", err) - return + t.Fatal("Failed to insert false value:", err) } rows, err := db.Query("SELECT id, value FROM foo") if err != nil { - t.Error("Unable to query foo table:", err) - return + t.Fatal("Unable to query foo table:", err) } defer rows.Close() @@ -272,8 +240,7 @@ func TestBooleanRoundtrip(t *testing.T) { func TestTimestamp(t *testing.T) { db, err := sql.Open("sqlite3", "./foo.db") if err != nil { - t.Error("Failed to open database:", err) - return + t.Fatal("Failed to open database:", err) } defer os.Remove("./foo.db") defer db.Close() @@ -281,34 +248,29 @@ 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.Error("Failed to create table:", err) - return + t.Fatal("Failed to create table:", err) } 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.Error("Failed to insert timestamp:", err) - return + t.Fatal("Failed to insert timestamp:", err) } 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.Error("Failed to insert timestamp:", err) - return + t.Fatal("Failed to insert timestamp:", err) } _, err = db.Exec("INSERT INTO foo(id, ts) VALUES(3, ?)", "nonsense") if err != nil { - t.Error("Failed to insert nonsense:", err) - return + t.Fatal("Failed to insert nonsense:", err) } rows, err := db.Query("SELECT id, ts FROM foo ORDER BY id ASC") if err != nil { - t.Error("Unable to query foo table:", err) - return + t.Fatal("Unable to query foo table:", err) } defer rows.Close() @@ -351,8 +313,7 @@ func TestTimestamp(t *testing.T) { func TestBoolean(t *testing.T) { db, err := sql.Open("sqlite3", "./foo.db") if err != nil { - t.Error("Failed to open database:", err) - return + t.Fatal("Failed to open database:", err) } defer os.Remove("./foo.db") @@ -360,35 +321,30 @@ func TestBoolean(t *testing.T) { _, err = db.Exec("CREATE TABLE foo(id INTEGER, fbool BOOLEAN)") if err != nil { - t.Error("Failed to create table:", err) - return + t.Fatal("Failed to create table:", err) } bool1 := true _, err = db.Exec("INSERT INTO foo(id, fbool) VALUES(1, ?)", bool1) if err != nil { - t.Error("Failed to insert boolean:", err) - return + t.Fatal("Failed to insert boolean:", err) } bool2 := false _, err = db.Exec("INSERT INTO foo(id, fbool) VALUES(2, ?)", bool2) if err != nil { - t.Error("Failed to insert boolean:", err) - return + t.Fatal("Failed to insert boolean:", err) } bool3 := "nonsense" _, err = db.Exec("INSERT INTO foo(id, fbool) VALUES(3, ?)", bool3) if err != nil { - t.Error("Failed to insert nonsense:", err) - return + t.Fatal("Failed to insert nonsense:", err) } rows, err := db.Query("SELECT id, fbool FROM foo where fbool is ?", bool1) if err != nil { - t.Error("Unable to query foo table:", err) - return + t.Fatal("Unable to query foo table:", err) } counter := 0 @@ -397,53 +353,45 @@ func TestBoolean(t *testing.T) { for rows.Next() { if err := rows.Scan(&id, &fbool); err != nil { - t.Error("Unable to scan results:", err) - return + t.Fatal("Unable to scan results:", err) } counter++ } if counter != 1 { - t.Errorf("Expected 1 row but %v", counter) - return + t.Fatalf("Expected 1 row but %v", counter) } if id != 1 && fbool != true { - t.Errorf("Value for id 1 should be %v, not %v", bool1, fbool) - return + t.Fatalf("Value for id 1 should be %v, not %v", bool1, fbool) } rows, err = db.Query("SELECT id, fbool FROM foo where fbool is ?", bool2) if err != nil { - t.Error("Unable to query foo table:", err) - return + t.Fatal("Unable to query foo table:", err) } counter = 0 for rows.Next() { if err := rows.Scan(&id, &fbool); err != nil { - t.Error("Unable to scan results:", err) - return + t.Fatal("Unable to scan results:", err) } counter++ } if counter != 1 { - t.Errorf("Expected 1 row but %v", counter) - return + t.Fatalf("Expected 1 row but %v", counter) } if id != 2 && fbool != false { - t.Errorf("Value for id 2 should be %v, not %v", bool2, fbool) - return + t.Fatalf("Value for id 2 should be %v, not %v", bool2, fbool) } // make sure "nonsense" triggered an error rows, err = db.Query("SELECT id, fbool FROM foo where id=?;", 3) if err != nil { - t.Error("Unable to query foo table:", err) - return + t.Fatal("Unable to query foo table:", err) } rows.Next() -- cgit v1.2.3