sql/sqlite_result_code_unittest.cc

   1 // Copyright 2022 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "sql/sqlite_result_code.h"
   6
   7 #include "base/test/gtest_util.h"
   8 #include "base/test/metrics/histogram_tester.h"
   9 #include "sql/sqlite_result_code_values.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11 #include "third_party/sqlite/sqlite3.h"
  12
  13 namespace sql {
  14
  15 namespace {
  16
  17 TEST(SqliteResultCodeTest, ToSqliteResultCode_Success) {
  18   EXPECT_EQ(SqliteResultCode::kOk, ToSqliteResultCode(SQLITE_OK));
  19   EXPECT_EQ(SqliteResultCode::kDone, ToSqliteResultCode(SQLITE_DONE));
  20   EXPECT_EQ(SqliteResultCode::kRow, ToSqliteResultCode(SQLITE_ROW));
  21 }
  22
  23 TEST(SqliteResultCodeTest, ToSqliteResultCode_PrimaryErrorCodes) {
  24   EXPECT_EQ(SqliteResultCode::kIo, ToSqliteResultCode(SQLITE_IOERR));
  25   EXPECT_EQ(SqliteResultCode::kCorrupt, ToSqliteResultCode(SQLITE_CORRUPT));
  26   EXPECT_EQ(SqliteResultCode::kConstraint,
  27             ToSqliteResultCode(SQLITE_CONSTRAINT));
  28 }
  29
  30 TEST(SqliteResultCodeTest, ToSqliteResultCode_ExtendedErrorCodes) {
  31   EXPECT_EQ(SqliteResultCode::kIoRead, ToSqliteResultCode(SQLITE_IOERR_READ));
  32   EXPECT_EQ(SqliteResultCode::kIoWrite, ToSqliteResultCode(SQLITE_IOERR_WRITE));
  33   EXPECT_EQ(SqliteResultCode::kCorruptIndex,
  34             ToSqliteResultCode(SQLITE_CORRUPT_INDEX));
  35   EXPECT_EQ(SqliteResultCode::kConstraintUnique,
  36             ToSqliteResultCode(SQLITE_CONSTRAINT_UNIQUE));
  37 }
  38
  39 TEST(SqliteResultCodeTest, ToSqliteResultCode_MissingLowValue) {
  40   EXPECT_DCHECK_DEATH_WITH(ToSqliteResultCode(-65536),
  41                            "Unsupported SQLite result code: -65536");
  42 }
  43
  44 TEST(SqliteResultCodeTest, ToSqliteResultCode_MissingHighValue) {
  45   EXPECT_DCHECK_DEATH_WITH(ToSqliteResultCode(65536),
  46                            "Unsupported SQLite result code: 65536");
  47 }
  48
  49 TEST(SqliteResultCodeTest, ToSqliteResultCode_SqliteInternalError) {
  50 #if DCHECK_IS_ON()
  51   EXPECT_DCHECK_DEATH_WITH(ToSqliteResultCode(SQLITE_INTERNAL),
  52                            "SQLite reported code marked for internal use: 2");
  53 #else
  54   EXPECT_EQ(SqliteResultCode::kInternal, ToSqliteResultCode(SQLITE_INTERNAL));
  55 #endif
  56 }
  57
  58 TEST(SqliteResultCodeTest, ToSqliteResultCode_ChromeBugError) {
  59 #if DCHECK_IS_ON()
  60   EXPECT_DCHECK_DEATH_WITH(
  61       ToSqliteResultCode(SQLITE_NOTFOUND),
  62       "SQLite reported code that should never show up in Chrome: 12");
  63 #else
  64   EXPECT_EQ(SqliteResultCode::kNotFound, ToSqliteResultCode(SQLITE_NOTFOUND));
  65 #endif
  66 }
  67
  68 TEST(SqliteResultCodeTest, ToSqliteErrorCode_Success_Ok) {
  69   EXPECT_DCHECK_DEATH_WITH(
  70       ToSqliteErrorCode(SqliteResultCode::kOk),
  71       "ToSqliteErrorCode called with non-error result code: 0");
  72 }
  73
  74 TEST(SqliteResultCodeTest, ToSqliteErrorCode_Success_Done) {
  75   EXPECT_DCHECK_DEATH_WITH(
  76       ToSqliteErrorCode(SqliteResultCode::kDone),
  77       "ToSqliteErrorCode called with non-error result code: 101");
  78 }
  79
  80 TEST(SqliteResultCodeTest, ToSqliteErrorCode_Success_Row) {
  81   EXPECT_DCHECK_DEATH_WITH(
  82       ToSqliteErrorCode(SqliteResultCode::kRow),
  83       "ToSqliteErrorCode called with non-error result code: 100");
  84 }
  85
  86 TEST(SqliteResultCodeTest, ToSqliteErrorCode_PrimaryErrorCodes) {
  87   EXPECT_EQ(SqliteErrorCode::kIo, ToSqliteErrorCode(SqliteResultCode::kIo));
  88   EXPECT_EQ(SqliteErrorCode::kCorrupt,
  89             ToSqliteErrorCode(SqliteResultCode::kCorrupt));
  90   EXPECT_EQ(SqliteErrorCode::kConstraint,
  91             ToSqliteErrorCode(SqliteResultCode::kConstraint));
  92 }
  93
  94 TEST(SqliteResultCodeTest, ToSqliteErrorCode_ExtendedErrorCodes) {
  95   EXPECT_EQ(SqliteErrorCode::kIoRead,
  96             ToSqliteErrorCode(SqliteResultCode::kIoRead));
  97   EXPECT_EQ(SqliteErrorCode::kIoWrite,
  98             ToSqliteErrorCode(SqliteResultCode::kIoWrite));
  99   EXPECT_EQ(SqliteErrorCode::kCorruptIndex,
 100             ToSqliteErrorCode(SqliteResultCode::kCorruptIndex));
 101   EXPECT_EQ(SqliteErrorCode::kConstraintUnique,
 102             ToSqliteErrorCode(SqliteResultCode::kConstraintUnique));
 103 }
 104
 105 TEST(SqliteResultCodeTest, ToSqliteErrorCode_SqliteInternalError) {
 106 #if DCHECK_IS_ON()
 107   EXPECT_DCHECK_DEATH_WITH(ToSqliteErrorCode(SqliteResultCode::kInternal),
 108                            "SQLite reported code marked for internal use: 2");
 109 #else
 110   EXPECT_EQ(SqliteErrorCode::kInternal,
 111             ToSqliteErrorCode(SqliteResultCode::kInternal));
 112 #endif
 113 }
 114
 115 TEST(SqliteResultCodeTest, ToSqliteErrorCode_ChromeBugError) {
 116 #if DCHECK_IS_ON()
 117   EXPECT_DCHECK_DEATH_WITH(
 118       ToSqliteErrorCode(SqliteResultCode::kNotFound),
 119       "SQLite reported code that should never show up in Chrome: 12");
 120 #else
 121   EXPECT_EQ(SqliteErrorCode::kNotFound,
 122             ToSqliteErrorCode(SqliteResultCode::kNotFound));
 123 #endif
 124 }
 125
 126 TEST(SqliteResultCodeTest, ToSqliteErrorCode_Success) {
 127   EXPECT_TRUE(IsSqliteSuccessCode(SqliteResultCode::kOk));
 128   EXPECT_TRUE(IsSqliteSuccessCode(SqliteResultCode::kDone));
 129   EXPECT_TRUE(IsSqliteSuccessCode(SqliteResultCode::kRow));
 130 }
 131
 132 TEST(SqliteResultCodeTest, IsSqliteSuccessCode_PrimaryErrorCodes) {
 133   EXPECT_FALSE(IsSqliteSuccessCode(SqliteResultCode::kIo));
 134   EXPECT_FALSE(IsSqliteSuccessCode(SqliteResultCode::kCorrupt));
 135   EXPECT_FALSE(IsSqliteSuccessCode(SqliteResultCode::kConstraint));
 136 }
 137
 138 TEST(SqliteResultCodeTest, IsSqliteSuccessCode_ExtendedErrorCodes) {
 139   EXPECT_FALSE(IsSqliteSuccessCode(SqliteResultCode::kIoRead));
 140   EXPECT_FALSE(IsSqliteSuccessCode(SqliteResultCode::kIoWrite));
 141   EXPECT_FALSE(IsSqliteSuccessCode(SqliteResultCode::kCorruptIndex));
 142   EXPECT_FALSE(IsSqliteSuccessCode(SqliteResultCode::kConstraintUnique));
 143 }
 144
 145 TEST(SqliteResultCodeTest, IsSqliteSuccessCode_SqliteInternalError) {
 146 #if DCHECK_IS_ON()
 147   EXPECT_DCHECK_DEATH_WITH(IsSqliteSuccessCode(SqliteResultCode::kInternal),
 148                            "SQLite reported code marked for internal use: 2");
 149 #else
 150   EXPECT_FALSE(IsSqliteSuccessCode(SqliteResultCode::kInternal));
 151 #endif
 152 }
 153
 154 TEST(SqliteResultCodeTest, IsSqliteSuccessCode_ChromeBugError) {
 155 #if DCHECK_IS_ON()
 156   EXPECT_DCHECK_DEATH_WITH(
 157       IsSqliteSuccessCode(SqliteResultCode::kNotFound),
 158       "SQLite reported code that should never show up in Chrome: 12");
 159 #else
 160   EXPECT_FALSE(IsSqliteSuccessCode(SqliteResultCode::kNotFound));
 161 #endif
 162 }
 163
 164 TEST(SqliteResultCodeTest, ToSqliteLoggedResultCode_Success) {
 165   EXPECT_EQ(SqliteLoggedResultCode::kNoError,
 166             ToSqliteLoggedResultCode(SQLITE_OK));
 167   EXPECT_EQ(SqliteLoggedResultCode::kNoError,
 168             ToSqliteLoggedResultCode(SQLITE_DONE));
 169   EXPECT_EQ(SqliteLoggedResultCode::kNoError,
 170             ToSqliteLoggedResultCode(SQLITE_ROW));
 171 }
 172
 173 TEST(SqliteResultCodeTest, ToSqliteLoggedResultCode_PrimaryErrorCodes) {
 174   EXPECT_EQ(SqliteLoggedResultCode::kIo,
 175             ToSqliteLoggedResultCode(SQLITE_IOERR));
 176   EXPECT_EQ(SqliteLoggedResultCode::kCorrupt,
 177             ToSqliteLoggedResultCode(SQLITE_CORRUPT));
 178   EXPECT_EQ(SqliteLoggedResultCode::kConstraint,
 179             ToSqliteLoggedResultCode(SQLITE_CONSTRAINT));
 180 }
 181
 182 TEST(SqliteResultCodeTest, ToSqliteLoggedResultCode_ExtendedErrorCodes) {
 183   EXPECT_EQ(SqliteLoggedResultCode::kIoRead,
 184             ToSqliteLoggedResultCode(SQLITE_IOERR_READ));
 185   EXPECT_EQ(SqliteLoggedResultCode::kIoWrite,
 186             ToSqliteLoggedResultCode(SQLITE_IOERR_WRITE));
 187   EXPECT_EQ(SqliteLoggedResultCode::kCorruptIndex,
 188             ToSqliteLoggedResultCode(SQLITE_CORRUPT_INDEX));
 189   EXPECT_EQ(SqliteLoggedResultCode::kConstraintUnique,
 190             ToSqliteLoggedResultCode(SQLITE_CONSTRAINT_UNIQUE));
 191 }
 192
 193 TEST(SqliteResultCodeTest, ToSqliteLoggedResultCode_MissingLowValue) {
 194 #if DCHECK_IS_ON()
 195   EXPECT_DCHECK_DEATH_WITH(ToSqliteLoggedResultCode(-65536),
 196                            "Unsupported SQLite result code: -65536");
 197 #else
 198   EXPECT_EQ(SqliteLoggedResultCode::kUnusedChrome,
 199             ToSqliteLoggedResultCode(-65536));
 200 #endif
 201 }
 202
 203 TEST(SqliteResultCodeTest, ToSqliteLoggedResultCode_MissingHighValue) {
 204 #if DCHECK_IS_ON()
 205   EXPECT_DCHECK_DEATH_WITH(ToSqliteLoggedResultCode(65536),
 206                            "Unsupported SQLite result code: 65536");
 207 #else
 208   EXPECT_EQ(SqliteLoggedResultCode::kUnusedChrome,
 209             ToSqliteLoggedResultCode(65536));
 210 #endif
 211 }
 212
 213 TEST(SqliteResultCodeTest, ToSqliteLoggedResultCode_SqliteInternalError) {
 214 #if DCHECK_IS_ON()
 215   EXPECT_DCHECK_DEATH_WITH(ToSqliteLoggedResultCode(SQLITE_INTERNAL),
 216                            "SQLite reported code marked for internal use: 2");
 217 #else
 218   EXPECT_EQ(SqliteLoggedResultCode::kUnusedSqlite,
 219             ToSqliteLoggedResultCode(SQLITE_INTERNAL));
 220 #endif
 221 }
 222
 223 TEST(SqliteResultCodeTest, ToSqliteLoggedResultCode_ChromeBugError) {
 224 #if DCHECK_IS_ON()
 225   EXPECT_DCHECK_DEATH_WITH(
 226       ToSqliteLoggedResultCode(SQLITE_NOTFOUND),
 227       "SQLite reported code that should never show up in Chrome: 12");
 228 #else
 229   EXPECT_EQ(SqliteLoggedResultCode::kUnusedChrome,
 230             ToSqliteLoggedResultCode(SQLITE_NOTFOUND));
 231 #endif
 232 }
 233
 234 TEST(SqliteResultCodeTest, UmaHistogramSqliteResult_Success) {
 235   base::HistogramTester histogram_tester;
 236   UmaHistogramSqliteResult("Sql.ResultTest", SQLITE_OK);
 237   histogram_tester.ExpectTotalCount("Sql.ResultTest", 1);
 238   histogram_tester.ExpectBucketCount("Sql.ResultTest",
 239                                      SqliteLoggedResultCode::kNoError, 1);
 240 }
 241
 242 TEST(SqliteResultCodeTest, UmaHistogramSqliteResult_PrimaryErrorCode) {
 243   base::HistogramTester histogram_tester;
 244   UmaHistogramSqliteResult("Sql.ResultTest", SQLITE_CORRUPT);
 245   histogram_tester.ExpectTotalCount("Sql.ResultTest", 1);
 246   histogram_tester.ExpectBucketCount("Sql.ResultTest",
 247                                      SqliteLoggedResultCode::kCorrupt, 1);
 248 }
 249
 250 TEST(SqliteResultCodeTest, UmaHistogramSqliteResult_ExtendedErrorCode) {
 251   base::HistogramTester histogram_tester;
 252   UmaHistogramSqliteResult("Sql.ResultTest", SQLITE_CORRUPT_INDEX);
 253   histogram_tester.ExpectTotalCount("Sql.ResultTest", 1);
 254   histogram_tester.ExpectBucketCount("Sql.ResultTest",
 255                                      SqliteLoggedResultCode::kCorruptIndex, 1);
 256 }
 257
 258 TEST(SqliteResultCodeTest, CheckMapping) {
 259   CheckSqliteLoggedResultCodeForTesting();
 260 }
 261
 262 }  // namespace
 263
 264 }  // namespace sql