[sql] Verify that recover works for multiple page sizes.

sql/recovery_unittest.cc

 // Copyright 2013 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 "sql/recovery.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.h"
 #include "sql/connection.h"
 #include "sql/meta_table.h"
 #include "sql/statement.h"
 #include "sql/test/paths.h"
 #include "sql/test/scoped_error_expecter.h"
 #include "sql/test/sql_test_base.h"
 #include "sql/test/test_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/sqlite/sqlite3.h"
@@ skipping 803 matching lines @@
     ASSERT_FALSE(recovery.get());
 
     ASSERT_TRUE(expecter.SawExpectedErrors());
   }
 
   // Verify that the failure was in the right place with the expected code.
   tester.ExpectBucketCount(kEventHistogramName, kEventEnum, 1);
   tester.ExpectBucketCount(kErrorHistogramName, SQLITE_NOTADB, 1);
 }
 
-}  // namespace
+// Helper for SQLRecoveryTest.PageSize.  Creates a fresh db based on db_prefix,
+// with the given initial page size, and verifies it against the expected size.
+// Then changes to the final page size and recovers, verifying that the
+// recovered database ends up with the expected final page size.
+void TestPageSize(const base::FilePath& db_prefix,
+                  int initial_page_size,
+                  const std::string& expected_initial_page_size,
+                  int final_page_size,
+                  const std::string& expected_final_page_size) {
+  SCOPED_TRACE(
+      base::StringPrintf("page sizes {initial=%d/%s, final=%d/%s}",
+                         initial_page_size, expected_initial_page_size.c_str(),
+                         final_page_size, expected_final_page_size.c_str()));
+
+  const char kCreateSql[] = "CREATE TABLE x (t TEXT)";
+  const char kInsertSql1[] = "INSERT INTO x VALUES ('This is a test')";
+  const char kInsertSql2[] = "INSERT INTO x VALUES ('That was a test')";
+  const char kSelectSql[] = "SELECT * FROM x ORDER BY t";
+
+  const base::FilePath db_path = db_prefix.InsertBeforeExtensionASCII(
+      base::StringPrintf("%d", initial_page_size));
+  sql::Connection::Delete(db_path);
+  sql::Connection db;
+  db.set_page_size(initial_page_size);
+  ASSERT_TRUE(db.Open(db_path));
+  ASSERT_TRUE(db.Execute(kCreateSql));
+  ASSERT_TRUE(db.Execute(kInsertSql1));
+  ASSERT_TRUE(db.Execute(kInsertSql2));
+  ASSERT_EQ(expected_initial_page_size,
+            ExecuteWithResult(&db, "PRAGMA page_size"));
+
+  // Recovery will use the page size set in the connection object, which may not
+  // match the file's page size.
+  db.set_page_size(final_page_size);
+  sql::Recovery::RecoverDatabase(&db, db_path);
+
+  // Recovery poisoned the handle, must re-open.
+  db.Close();
+
+  // Make sure the page size is read from the file.
+  db.set_page_size(0);
+  ASSERT_TRUE(db.Open(db_path));
+  ASSERT_EQ(expected_final_page_size,
+            ExecuteWithResult(&db, "PRAGMA page_size"));
+  EXPECT_EQ("That was a test\nThis is a test",
+            ExecuteWithResults(&db, kSelectSql, "|", "\n"));
+}
+
+// Verify that sql::Recovery maintains the page size, and the virtual table
+// works with page sizes other than SQLite's default.  Also verify the case
+// where the default page size has changed.
+TEST_F(SQLRecoveryTest, PageSize) {
+  const std::string default_page_size =
+      ExecuteWithResult(&db(), "PRAGMA page_size");
+
+  // The database should have the default page size after recovery.

[michaeln, 2016/10/27 00:02:29]

SCOPED_TRACE looks like a good tool for this

alternatively you could put the scopers up here
{ SCOPED_TRACE("default");
  TestPageSize(...); }

[Scott Hess - ex-Googler, 2016/10/27 19:14:58]

Indeed, and that removes the need for convoluted string-creation.

Then I re-crawled the googletest advanced guide and found
EXPECT_NO_FATAL_FAILURE(), which seems to target pretty much the case I want. 
So I'll switch to that.  Since this seems like a minor change, I'll let the bots
decide if it's reasonable from here...

+  TestPageSize(db_path(), 0, default_page_size, 0, default_page_size);
+
+  // Sync user 32k pages.
+  TestPageSize(db_path(), 32768, "32768", 32768, "32768");
+
+  // Many clients use 4k pages.  This is the SQLite default after 3.12.0.
+  TestPageSize(db_path(), 4096, "4096", 4096, "4096");
+
+  // 1k is the default page size before 3.12.0.
+  TestPageSize(db_path(), 1024, "1024", 1024, "1024");
+
+  // Databases with no page size specified should recover with the new default
+  // page size.  2k has never been the default page size.
+  ASSERT_NE("2048", default_page_size);
+  TestPageSize(db_path(), 2048, "2048", 0, default_page_size);
+}
+
+}  // namespac