Put debugging assertions into sql::Statement.

sql/connection_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/file_util.h"
 #include "base/scoped_temp_dir.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/sqlite/sqlite3.h"
@@ skipping 17 matching lines @@
   ScopedTempDir temp_dir_;
   sql::Connection db_;
 };
 
 TEST_F(SQLConnectionTest, Execute) {
   // Valid statement should return true.
   ASSERT_TRUE(db().Execute("CREATE TABLE foo (a, b)"));
   EXPECT_EQ(SQLITE_OK, db().GetErrorCode());
 
   // Invalid statement should fail.
-  ASSERT_FALSE(db().Execute("CREATE TAB foo (a, b"));
+  ASSERT_EQ(SQLITE_ERROR,
+            db().ExecuteAndReturnErrorCode("CREATE TAB foo (a, b"));
   EXPECT_EQ(SQLITE_ERROR, db().GetErrorCode());
 }
 
+TEST_F(SQLConnectionTest, ExecuteWithErrorCode) {
+  ASSERT_EQ(SQLITE_OK,
+            db().ExecuteAndReturnErrorCode("CREATE TABLE foo (a, b)"));
+  ASSERT_EQ(SQLITE_ERROR,
+            db().ExecuteAndReturnErrorCode("CREATE TABLE TABLE"));
+  ASSERT_EQ(SQLITE_ERROR,
+            db().ExecuteAndReturnErrorCode(
+                "INSERT INTO foo(a, b) VALUES (1, 2, 3, 4)"));
+}
+
 TEST_F(SQLConnectionTest, CachedStatement) {
   sql::StatementID id1("foo", 12);
 
   ASSERT_TRUE(db().Execute("CREATE TABLE foo (a, b)"));
   ASSERT_TRUE(db().Execute("INSERT INTO foo(a, b) VALUES (12, 13)"));
 
   // Create a new cached statement.
   {
     sql::Statement s(db().GetCachedStatement(id1, "SELECT a FROM foo"));
-    ASSERT_FALSE(!s);  // Test ! operator for validity.
+    ASSERT_TRUE(s.is_valid());
 
     ASSERT_TRUE(s.Step());
     EXPECT_EQ(12, s.ColumnInt(0));
   }
 
   // The statement should be cached still.
   EXPECT_TRUE(db().HasCachedStatement(id1));
 
   {
     // Get the same statement using different SQL. This should ignore our
     // SQL and use the cached one (so it will be valid).
     sql::Statement s(db().GetCachedStatement(id1, "something invalid("));
-    ASSERT_FALSE(!s);  // Test ! operator for validity.
+    ASSERT_TRUE(s.is_valid());
 
     ASSERT_TRUE(s.Step());
     EXPECT_EQ(12, s.ColumnInt(0));
   }
 
   // Make sure other statements aren't marked as cached.
   EXPECT_FALSE(db().HasCachedStatement(SQL_FROM_HERE));
 }
 
+TEST_F(SQLConnectionTest, IsSQLValidTest) {
+  ASSERT_TRUE(db().Execute("CREATE TABLE foo (a, b)"));
+  ASSERT_TRUE(db().IsSQLValid("SELECT a FROM foo"));
+  ASSERT_FALSE(db().IsSQLValid("SELECT no_exist FROM foo"));
+}
+
 TEST_F(SQLConnectionTest, DoesStuffExist) {
   // Test DoesTableExist.
   EXPECT_FALSE(db().DoesTableExist("foo"));
   ASSERT_TRUE(db().Execute("CREATE TABLE foo (a, b)"));
   EXPECT_TRUE(db().DoesTableExist("foo"));
 
   // Should be case sensitive.
   EXPECT_FALSE(db().DoesTableExist("FOO"));
 
   // Test DoesColumnExist.
@@ skipping 12 matching lines @@
   // Last insert row ID should be valid.
   int64 row = db().GetLastInsertRowId();
   EXPECT_LT(0, row);
 
   // It should be the primary key of the row we just inserted.
   sql::Statement s(db().GetUniqueStatement("SELECT value FROM foo WHERE id=?"));
   s.BindInt64(0, row);
   ASSERT_TRUE(s.Step());
   EXPECT_EQ(12, s.ColumnInt(0));
 }
-