content/browser/indexed_db/indexed_db_leveldb_coding_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   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 "content/browser/indexed_db/indexed_db_leveldb_coding.h"
   6
   7 #include <limits>
   8 #include <vector>
   9
  10 #include "base/basictypes.h"
  11 #include "base/strings/string16.h"
  12 #include "base/strings/string_piece.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "content/common/indexed_db/indexed_db_key.h"
  15 #include "content/common/indexed_db/indexed_db_key_path.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 using base::StringPiece;
  19 using WebKit::WebIDBKeyTypeDate;
  20 using WebKit::WebIDBKeyTypeNumber;
  21
  22 namespace content {
  23
  24 namespace {
  25
  26 static IndexedDBKey CreateArrayIDBKey() {
  27   return IndexedDBKey(IndexedDBKey::KeyArray());
  28 }
  29
  30 static IndexedDBKey CreateArrayIDBKey(const IndexedDBKey& key1) {
  31   IndexedDBKey::KeyArray array;
  32   array.push_back(key1);
  33   return IndexedDBKey(array);
  34 }
  35
  36 static IndexedDBKey CreateArrayIDBKey(const IndexedDBKey& key1,
  37                                       const IndexedDBKey& key2) {
  38   IndexedDBKey::KeyArray array;
  39   array.push_back(key1);
  40   array.push_back(key2);
  41   return IndexedDBKey(array);
  42 }
  43
  44 static std::string WrappedEncodeByte(char value) {
  45   std::string buffer;
  46   EncodeByte(value, &buffer);
  47   return buffer;
  48 }
  49
  50 TEST(IndexedDBLevelDBCodingTest, EncodeByte) {
  51   std::string expected;
  52   expected.push_back(0);
  53   unsigned char c;
  54
  55   c = 0;
  56   expected[0] = c;
  57   EXPECT_EQ(expected, WrappedEncodeByte(c));
  58
  59   c = 1;
  60   expected[0] = c;
  61   EXPECT_EQ(expected, WrappedEncodeByte(c));
  62
  63   c = 255;
  64   expected[0] = c;
  65   EXPECT_EQ(expected, WrappedEncodeByte(c));
  66 }
  67
  68 TEST(IndexedDBLevelDBCodingTest, DecodeByte) {
  69   std::vector<unsigned char> test_cases;
  70   test_cases.push_back(0);
  71   test_cases.push_back(1);
  72   test_cases.push_back(255);
  73
  74   for (size_t i = 0; i < test_cases.size(); ++i) {
  75     unsigned char n = test_cases[i];
  76     std::string v;
  77     EncodeByte(n, &v);
  78
  79     unsigned char res;
  80     ASSERT_GT(v.size(), static_cast<size_t>(0));
  81     StringPiece slice(v);
  82     EXPECT_TRUE(DecodeByte(&slice, &res));
  83     EXPECT_EQ(n, res);
  84     EXPECT_TRUE(slice.empty());
  85   }
  86
  87   {
  88     StringPiece slice;
  89     unsigned char value;
  90     EXPECT_FALSE(DecodeByte(&slice, &value));
  91   }
  92 }
  93
  94 static std::string WrappedEncodeBool(bool value) {
  95   std::string buffer;
  96   EncodeBool(value, &buffer);
  97   return buffer;
  98 }
  99
 100 TEST(IndexedDBLevelDBCodingTest, EncodeBool) {
 101   {
 102     std::string expected;
 103     expected.push_back(1);
 104     EXPECT_EQ(expected, WrappedEncodeBool(true));
 105   }
 106   {
 107     std::string expected;
 108     expected.push_back(0);
 109     EXPECT_EQ(expected, WrappedEncodeBool(false));
 110   }
 111 }
 112
 113 static int CompareKeys(const std::string& a, const std::string& b) {
 114   bool ok;
 115   int result = CompareEncodedIDBKeys(a, b, &ok);
 116   EXPECT_TRUE(ok);
 117   return result;
 118 }
 119
 120 TEST(IndexedDBLevelDBCodingTest, MaxIDBKey) {
 121   std::string max_key = MaxIDBKey();
 122
 123   std::string min_key = MinIDBKey();
 124   std::string array_key;
 125   EncodeIDBKey(IndexedDBKey(IndexedDBKey::KeyArray()), &array_key);
 126   std::string string_key;
 127   EncodeIDBKey(IndexedDBKey(ASCIIToUTF16("Hello world")), &string_key);
 128   std::string number_key;
 129   EncodeIDBKey(IndexedDBKey(3.14, WebIDBKeyTypeNumber), &number_key);
 130   std::string date_key;
 131   EncodeIDBKey(IndexedDBKey(1000000, WebIDBKeyTypeDate), &date_key);
 132
 133   EXPECT_GT(CompareKeys(max_key, min_key), 0);
 134   EXPECT_GT(CompareKeys(max_key, array_key), 0);
 135   EXPECT_GT(CompareKeys(max_key, string_key), 0);
 136   EXPECT_GT(CompareKeys(max_key, number_key), 0);
 137   EXPECT_GT(CompareKeys(max_key, date_key), 0);
 138 }
 139
 140 TEST(IndexedDBLevelDBCodingTest, MinIDBKey) {
 141   std::string min_key = MinIDBKey();
 142
 143   std::string max_key = MaxIDBKey();
 144   std::string array_key;
 145   EncodeIDBKey(IndexedDBKey(IndexedDBKey::KeyArray()), &array_key);
 146   std::string string_key;
 147   EncodeIDBKey(IndexedDBKey(ASCIIToUTF16("Hello world")), &string_key);
 148   std::string number_key;
 149   EncodeIDBKey(IndexedDBKey(3.14, WebIDBKeyTypeNumber), &number_key);
 150   std::string date_key;
 151   EncodeIDBKey(IndexedDBKey(1000000, WebIDBKeyTypeDate), &date_key);
 152
 153   EXPECT_LT(CompareKeys(min_key, max_key), 0);
 154   EXPECT_LT(CompareKeys(min_key, array_key), 0);
 155   EXPECT_LT(CompareKeys(min_key, string_key), 0);
 156   EXPECT_LT(CompareKeys(min_key, number_key), 0);
 157   EXPECT_LT(CompareKeys(min_key, date_key), 0);
 158 }
 159
 160 static std::string WrappedEncodeInt(int64 value) {
 161   std::string buffer;
 162   EncodeInt(value, &buffer);
 163   return buffer;
 164 }
 165
 166 TEST(IndexedDBLevelDBCodingTest, EncodeInt) {
 167   EXPECT_EQ(static_cast<size_t>(1), WrappedEncodeInt(0).size());
 168   EXPECT_EQ(static_cast<size_t>(1), WrappedEncodeInt(1).size());
 169   EXPECT_EQ(static_cast<size_t>(1), WrappedEncodeInt(255).size());
 170   EXPECT_EQ(static_cast<size_t>(2), WrappedEncodeInt(256).size());
 171   EXPECT_EQ(static_cast<size_t>(4), WrappedEncodeInt(0xffffffff).size());
 172 #ifdef NDEBUG
 173   EXPECT_EQ(static_cast<size_t>(8), WrappedEncodeInt(-1).size());
 174 #endif
 175 }
 176
 177 TEST(IndexedDBLevelDBCodingTest, DecodeBool) {
 178   {
 179     std::string encoded;
 180     encoded.push_back(1);
 181     StringPiece slice(encoded);
 182     bool value;
 183     EXPECT_TRUE(DecodeBool(&slice, &value));
 184     EXPECT_TRUE(value);
 185     EXPECT_TRUE(slice.empty());
 186   }
 187   {
 188     std::string encoded;
 189     encoded.push_back(0);
 190     StringPiece slice(encoded);
 191     bool value;
 192     EXPECT_TRUE(DecodeBool(&slice, &value));
 193     EXPECT_FALSE(value);
 194     EXPECT_TRUE(slice.empty());
 195   }
 196   {
 197     StringPiece slice;
 198     bool value;
 199     EXPECT_FALSE(DecodeBool(&slice, &value));
 200   }
 201 }
 202
 203 TEST(IndexedDBLevelDBCodingTest, DecodeInt) {
 204   std::vector<int64> test_cases;
 205   test_cases.push_back(0);
 206   test_cases.push_back(1);
 207   test_cases.push_back(255);
 208   test_cases.push_back(256);
 209   test_cases.push_back(65535);
 210   test_cases.push_back(655536);
 211   test_cases.push_back(7711192431755665792ll);
 212   test_cases.push_back(0x7fffffffffffffffll);
 213 #ifdef NDEBUG
 214   test_cases.push_back(-3);
 215 #endif
 216
 217   for (size_t i = 0; i < test_cases.size(); ++i) {
 218     int64 n = test_cases[i];
 219     std::string v = WrappedEncodeInt(n);
 220     ASSERT_GT(v.size(), static_cast<size_t>(0));
 221     StringPiece slice(v);
 222     int64 value;
 223     EXPECT_TRUE(DecodeInt(&slice, &value));
 224     EXPECT_EQ(n, value);
 225     EXPECT_TRUE(slice.empty());
 226
 227     // Verify decoding at an offset, to detect unaligned memory access.
 228     v.insert(v.begin(), static_cast<size_t>(1), static_cast<char>(0));
 229     slice = StringPiece(&*v.begin() + 1, v.size() - 1);
 230     EXPECT_TRUE(DecodeInt(&slice, &value));
 231     EXPECT_EQ(n, value);
 232     EXPECT_TRUE(slice.empty());
 233   }
 234   {
 235     StringPiece slice;
 236     int64 value;
 237     EXPECT_FALSE(DecodeInt(&slice, &value));
 238   }
 239 }
 240
 241 static std::string WrappedEncodeVarInt(int64 value) {
 242   std::string buffer;
 243   EncodeVarInt(value, &buffer);
 244   return buffer;
 245 }
 246
 247 TEST(IndexedDBLevelDBCodingTest, EncodeVarInt) {
 248   EXPECT_EQ(static_cast<size_t>(1), WrappedEncodeVarInt(0).size());
 249   EXPECT_EQ(static_cast<size_t>(1), WrappedEncodeVarInt(1).size());
 250   EXPECT_EQ(static_cast<size_t>(2), WrappedEncodeVarInt(255).size());
 251   EXPECT_EQ(static_cast<size_t>(2), WrappedEncodeVarInt(256).size());
 252   EXPECT_EQ(static_cast<size_t>(5), WrappedEncodeVarInt(0xffffffff).size());
 253   EXPECT_EQ(static_cast<size_t>(8),
 254             WrappedEncodeVarInt(0xfffffffffffffLL).size());
 255   EXPECT_EQ(static_cast<size_t>(9),
 256             WrappedEncodeVarInt(0x7fffffffffffffffLL).size());
 257 #ifdef NDEBUG
 258   EXPECT_EQ(static_cast<size_t>(10), WrappedEncodeVarInt(-100).size());
 259 #endif
 260 }
 261
 262 TEST(IndexedDBLevelDBCodingTest, DecodeVarInt) {
 263   std::vector<int64> test_cases;
 264   test_cases.push_back(0);
 265   test_cases.push_back(1);
 266   test_cases.push_back(255);
 267   test_cases.push_back(256);
 268   test_cases.push_back(65535);
 269   test_cases.push_back(655536);
 270   test_cases.push_back(7711192431755665792ll);
 271   test_cases.push_back(0x7fffffffffffffffll);
 272 #ifdef NDEBUG
 273   test_cases.push_back(-3);
 274 #endif
 275
 276   for (size_t i = 0; i < test_cases.size(); ++i) {
 277     int64 n = test_cases[i];
 278     std::string v = WrappedEncodeVarInt(n);
 279     ASSERT_GT(v.size(), static_cast<size_t>(0));
 280     StringPiece slice(v);
 281     int64 res;
 282     EXPECT_TRUE(DecodeVarInt(&slice, &res));
 283     EXPECT_EQ(n, res);
 284     EXPECT_TRUE(slice.empty());
 285
 286     slice = StringPiece(&*v.begin(), v.size() - 1);
 287     EXPECT_FALSE(DecodeVarInt(&slice, &res));
 288
 289     slice = StringPiece(&*v.begin(), static_cast<size_t>(0));
 290     EXPECT_FALSE(DecodeVarInt(&slice, &res));
 291
 292     // Verify decoding at an offset, to detect unaligned memory access.
 293     v.insert(v.begin(), static_cast<size_t>(1), static_cast<char>(0));
 294     slice = StringPiece(&*v.begin() + 1, v.size() - 1);
 295     EXPECT_TRUE(DecodeVarInt(&slice, &res));
 296     EXPECT_EQ(n, res);
 297     EXPECT_TRUE(slice.empty());
 298   }
 299 }
 300
 301 static std::string WrappedEncodeString(string16 value) {
 302   std::string buffer;
 303   EncodeString(value, &buffer);
 304   return buffer;
 305 }
 306
 307 TEST(IndexedDBLevelDBCodingTest, EncodeString) {
 308   const char16 test_string_a[] = {'f', 'o', 'o', '\0'};
 309   const char16 test_string_b[] = {0xdead, 0xbeef, '\0'};
 310
 311   EXPECT_EQ(static_cast<size_t>(0),
 312             WrappedEncodeString(ASCIIToUTF16("")).size());
 313   EXPECT_EQ(static_cast<size_t>(2),
 314             WrappedEncodeString(ASCIIToUTF16("a")).size());
 315   EXPECT_EQ(static_cast<size_t>(6),
 316             WrappedEncodeString(ASCIIToUTF16("foo")).size());
 317   EXPECT_EQ(static_cast<size_t>(6),
 318             WrappedEncodeString(string16(test_string_a)).size());
 319   EXPECT_EQ(static_cast<size_t>(4),
 320             WrappedEncodeString(string16(test_string_b)).size());
 321 }
 322
 323 TEST(IndexedDBLevelDBCodingTest, DecodeString) {
 324   const char16 test_string_a[] = {'f', 'o', 'o', '\0'};
 325   const char16 test_string_b[] = {0xdead, 0xbeef, '\0'};
 326
 327   std::vector<string16> test_cases;
 328   test_cases.push_back(string16());
 329   test_cases.push_back(ASCIIToUTF16("a"));
 330   test_cases.push_back(ASCIIToUTF16("foo"));
 331   test_cases.push_back(test_string_a);
 332   test_cases.push_back(test_string_b);
 333
 334   for (size_t i = 0; i < test_cases.size(); ++i) {
 335     const string16& test_case = test_cases[i];
 336     std::string v = WrappedEncodeString(test_case);
 337
 338     StringPiece slice;
 339     if (v.size()) {
 340       slice = StringPiece(&*v.begin(), v.size());
 341     }
 342
 343     string16 result;
 344     EXPECT_TRUE(DecodeString(&slice, &result));
 345     EXPECT_EQ(test_case, result);
 346     EXPECT_TRUE(slice.empty());
 347
 348     // Verify decoding at an offset, to detect unaligned memory access.
 349     v.insert(v.begin(), static_cast<size_t>(1), static_cast<char>(0));
 350     slice = StringPiece(&*v.begin() + 1, v.size() - 1);
 351     EXPECT_TRUE(DecodeString(&slice, &result));
 352     EXPECT_EQ(test_case, result);
 353     EXPECT_TRUE(slice.empty());
 354   }
 355 }
 356
 357 static std::string WrappedEncodeStringWithLength(string16 value) {
 358   std::string buffer;
 359   EncodeStringWithLength(value, &buffer);
 360   return buffer;
 361 }
 362
 363 TEST(IndexedDBLevelDBCodingTest, EncodeStringWithLength) {
 364   const char16 test_string_a[] = {'f', 'o', 'o', '\0'};
 365   const char16 test_string_b[] = {0xdead, 0xbeef, '\0'};
 366
 367   EXPECT_EQ(static_cast<size_t>(1),
 368             WrappedEncodeStringWithLength(string16()).size());
 369   EXPECT_EQ(static_cast<size_t>(3),
 370             WrappedEncodeStringWithLength(ASCIIToUTF16("a")).size());
 371   EXPECT_EQ(static_cast<size_t>(7),
 372             WrappedEncodeStringWithLength(string16(test_string_a)).size());
 373   EXPECT_EQ(static_cast<size_t>(5),
 374             WrappedEncodeStringWithLength(string16(test_string_b)).size());
 375 }
 376
 377 TEST(IndexedDBLevelDBCodingTest, DecodeStringWithLength) {
 378   const char16 test_string_a[] = {'f', 'o', 'o', '\0'};
 379   const char16 test_string_b[] = {0xdead, 0xbeef, '\0'};
 380
 381   const int kLongStringLen = 1234;
 382   char16 long_string[kLongStringLen + 1];
 383   for (int i = 0; i < kLongStringLen; ++i)
 384     long_string[i] = i;
 385   long_string[kLongStringLen] = 0;
 386
 387   std::vector<string16> test_cases;
 388   test_cases.push_back(ASCIIToUTF16(""));
 389   test_cases.push_back(ASCIIToUTF16("a"));
 390   test_cases.push_back(ASCIIToUTF16("foo"));
 391   test_cases.push_back(string16(test_string_a));
 392   test_cases.push_back(string16(test_string_b));
 393   test_cases.push_back(string16(long_string));
 394
 395   for (size_t i = 0; i < test_cases.size(); ++i) {
 396     string16 s = test_cases[i];
 397     std::string v = WrappedEncodeStringWithLength(s);
 398     ASSERT_GT(v.size(), static_cast<size_t>(0));
 399     StringPiece slice(v);
 400     string16 res;
 401     EXPECT_TRUE(DecodeStringWithLength(&slice, &res));
 402     EXPECT_EQ(s, res);
 403     EXPECT_TRUE(slice.empty());
 404
 405     slice = StringPiece(&*v.begin(), v.size() - 1);
 406     EXPECT_FALSE(DecodeStringWithLength(&slice, &res));
 407
 408     slice = StringPiece(&*v.begin(), static_cast<size_t>(0));
 409     EXPECT_FALSE(DecodeStringWithLength(&slice, &res));
 410
 411     // Verify decoding at an offset, to detect unaligned memory access.
 412     v.insert(v.begin(), static_cast<size_t>(1), static_cast<char>(0));
 413     slice = StringPiece(&*v.begin() + 1, v.size() - 1);
 414     EXPECT_TRUE(DecodeStringWithLength(&slice, &res));
 415     EXPECT_EQ(s, res);
 416     EXPECT_TRUE(slice.empty());
 417   }
 418 }
 419
 420 static int CompareStrings(const std::string& p, const std::string& q) {
 421   bool ok;
 422   DCHECK(!p.empty());
 423   DCHECK(!q.empty());
 424   StringPiece slice_p(p);
 425   StringPiece slice_q(q);
 426   int result = CompareEncodedStringsWithLength(&slice_p, &slice_q, &ok);
 427   EXPECT_TRUE(ok);
 428   EXPECT_TRUE(slice_p.empty());
 429   EXPECT_TRUE(slice_q.empty());
 430   return result;
 431 }
 432
 433 TEST(IndexedDBLevelDBCodingTest, CompareEncodedStringsWithLength) {
 434   const char16 test_string_a[] = {0x1000, 0x1000, '\0'};
 435   const char16 test_string_b[] = {0x1000, 0x1000, 0x1000, '\0'};
 436   const char16 test_string_c[] = {0x1000, 0x1000, 0x1001, '\0'};
 437   const char16 test_string_d[] = {0x1001, 0x1000, 0x1000, '\0'};
 438   const char16 test_string_e[] = {0xd834, 0xdd1e, '\0'};
 439   const char16 test_string_f[] = {0xfffd, '\0'};
 440
 441   std::vector<string16> test_cases;
 442   test_cases.push_back(ASCIIToUTF16(""));
 443   test_cases.push_back(ASCIIToUTF16("a"));
 444   test_cases.push_back(ASCIIToUTF16("b"));
 445   test_cases.push_back(ASCIIToUTF16("baaa"));
 446   test_cases.push_back(ASCIIToUTF16("baab"));
 447   test_cases.push_back(ASCIIToUTF16("c"));
 448   test_cases.push_back(string16(test_string_a));
 449   test_cases.push_back(string16(test_string_b));
 450   test_cases.push_back(string16(test_string_c));
 451   test_cases.push_back(string16(test_string_d));
 452   test_cases.push_back(string16(test_string_e));
 453   test_cases.push_back(string16(test_string_f));
 454
 455   for (size_t i = 0; i < test_cases.size() - 1; ++i) {
 456     string16 a = test_cases[i];
 457     string16 b = test_cases[i + 1];
 458
 459     EXPECT_LT(a.compare(b), 0);
 460     EXPECT_GT(b.compare(a), 0);
 461     EXPECT_EQ(a.compare(a), 0);
 462     EXPECT_EQ(b.compare(b), 0);
 463
 464     std::string encoded_a = WrappedEncodeStringWithLength(a);
 465     EXPECT_TRUE(encoded_a.size());
 466     std::string encoded_b = WrappedEncodeStringWithLength(b);
 467     EXPECT_TRUE(encoded_a.size());
 468
 469     EXPECT_LT(CompareStrings(encoded_a, encoded_b), 0);
 470     EXPECT_GT(CompareStrings(encoded_b, encoded_a), 0);
 471     EXPECT_EQ(CompareStrings(encoded_a, encoded_a), 0);
 472     EXPECT_EQ(CompareStrings(encoded_b, encoded_b), 0);
 473   }
 474 }
 475
 476 static std::string WrappedEncodeDouble(double value) {
 477   std::string buffer;
 478   EncodeDouble(value, &buffer);
 479   return buffer;
 480 }
 481
 482 TEST(IndexedDBLevelDBCodingTest, EncodeDouble) {
 483   EXPECT_EQ(static_cast<size_t>(8), WrappedEncodeDouble(0).size());
 484   EXPECT_EQ(static_cast<size_t>(8), WrappedEncodeDouble(3.14).size());
 485 }
 486
 487 TEST(IndexedDBLevelDBCodingTest, DecodeDouble) {
 488   std::vector<double> test_cases;
 489   test_cases.push_back(3.14);
 490   test_cases.push_back(-3.14);
 491
 492   for (size_t i = 0; i < test_cases.size(); ++i) {
 493     double value = test_cases[i];
 494     std::string v = WrappedEncodeDouble(value);
 495     ASSERT_GT(v.size(), static_cast<size_t>(0));
 496     StringPiece slice(v);
 497     double result;
 498     EXPECT_TRUE(DecodeDouble(&slice, &result));
 499     EXPECT_EQ(value, result);
 500     EXPECT_TRUE(slice.empty());
 501
 502     slice = StringPiece(&*v.begin(), v.size() - 1);
 503     EXPECT_FALSE(DecodeDouble(&slice, &result));
 504
 505     slice = StringPiece(&*v.begin(), static_cast<size_t>(0));
 506     EXPECT_FALSE(DecodeDouble(&slice, &result));
 507
 508     // Verify decoding at an offset, to detect unaligned memory access.
 509     v.insert(v.begin(), static_cast<size_t>(1), static_cast<char>(0));
 510     slice = StringPiece(&*v.begin() + 1, v.size() - 1);
 511     EXPECT_TRUE(DecodeDouble(&slice, &result));
 512     EXPECT_EQ(value, result);
 513     EXPECT_TRUE(slice.empty());
 514   }
 515 }
 516
 517 TEST(IndexedDBLevelDBCodingTest, EncodeDecodeIDBKey) {
 518   IndexedDBKey expected_key;
 519   scoped_ptr<IndexedDBKey> decoded_key;
 520   std::string v;
 521   StringPiece slice;
 522
 523   std::vector<IndexedDBKey> test_cases;
 524   test_cases.push_back(IndexedDBKey(1234, WebIDBKeyTypeNumber));
 525   test_cases.push_back(IndexedDBKey(7890, WebIDBKeyTypeDate));
 526   test_cases.push_back(IndexedDBKey(ASCIIToUTF16("Hello World!")));
 527   test_cases.push_back(IndexedDBKey(IndexedDBKey::KeyArray()));
 528
 529   IndexedDBKey::KeyArray array;
 530   array.push_back(IndexedDBKey(1234, WebIDBKeyTypeNumber));
 531   array.push_back(IndexedDBKey(7890, WebIDBKeyTypeDate));
 532   array.push_back(IndexedDBKey(ASCIIToUTF16("Hello World!")));
 533   array.push_back(IndexedDBKey(IndexedDBKey::KeyArray()));
 534   test_cases.push_back(IndexedDBKey(array));
 535
 536   for (size_t i = 0; i < test_cases.size(); ++i) {
 537     expected_key = test_cases[i];
 538     v.clear();
 539     EncodeIDBKey(expected_key, &v);
 540     slice = StringPiece(&*v.begin(), v.size());
 541     EXPECT_TRUE(DecodeIDBKey(&slice, &decoded_key));
 542     EXPECT_TRUE(decoded_key->IsEqual(expected_key));
 543     EXPECT_TRUE(slice.empty());
 544
 545     slice = StringPiece(&*v.begin(), v.size() - 1);
 546     EXPECT_FALSE(DecodeIDBKey(&slice, &decoded_key));
 547
 548     slice = StringPiece(&*v.begin(), static_cast<size_t>(0));
 549     EXPECT_FALSE(DecodeIDBKey(&slice, &decoded_key));
 550   }
 551 }
 552
 553 static std::string WrappedEncodeIDBKeyPath(const IndexedDBKeyPath& value) {
 554   std::string buffer;
 555   EncodeIDBKeyPath(value, &buffer);
 556   return buffer;
 557 }
 558
 559 TEST(IndexedDBLevelDBCodingTest, EncodeDecodeIDBKeyPath) {
 560   std::vector<IndexedDBKeyPath> key_paths;
 561   std::vector<std::string> encoded_paths;
 562
 563   {
 564     key_paths.push_back(IndexedDBKeyPath());
 565     char expected[] = {0, 0,  // Header
 566                        0      // Type is null
 567     };
 568     encoded_paths.push_back(
 569         std::string(expected, expected + arraysize(expected)));
 570   }
 571
 572   {
 573     key_paths.push_back(IndexedDBKeyPath(string16()));
 574     char expected[] = {0, 0,  // Header
 575                        1,     // Type is string
 576                        0      // Length is 0
 577     };
 578     encoded_paths.push_back(
 579         std::string(expected, expected + arraysize(expected)));
 580   }
 581
 582   {
 583     key_paths.push_back(IndexedDBKeyPath(ASCIIToUTF16("foo")));
 584     char expected[] = {0, 0,                      // Header
 585                        1,                         // Type is string
 586                        3, 0, 'f', 0, 'o', 0, 'o'  // String length 3, UTF-16BE
 587     };
 588     encoded_paths.push_back(
 589         std::string(expected, expected + arraysize(expected)));
 590   }
 591
 592   {
 593     key_paths.push_back(IndexedDBKeyPath(ASCIIToUTF16("foo.bar")));
 594     char expected[] = {0, 0,  // Header
 595                        1,     // Type is string
 596                        7, 0, 'f', 0, 'o', 0, 'o', 0, '.', 0, 'b', 0, 'a', 0,
 597                        'r'  // String length 7, UTF-16BE
 598     };
 599     encoded_paths.push_back(
 600         std::string(expected, expected + arraysize(expected)));
 601   }
 602
 603   {
 604     std::vector<string16> array;
 605     array.push_back(string16());
 606     array.push_back(ASCIIToUTF16("foo"));
 607     array.push_back(ASCIIToUTF16("foo.bar"));
 608
 609     key_paths.push_back(IndexedDBKeyPath(array));
 610     char expected[] = {0, 0,                       // Header
 611                        2, 3,                       // Type is array, length is 3
 612                        0,                          // Member 1 (String length 0)
 613                        3, 0, 'f', 0, 'o', 0, 'o',  // Member 2 (String length 3)
 614                        7, 0, 'f', 0, 'o', 0, 'o', 0, '.', 0, 'b', 0, 'a', 0,
 615                        'r'  // Member 3 (String length 7)
 616     };
 617     encoded_paths.push_back(
 618         std::string(expected, expected + arraysize(expected)));
 619   }
 620
 621   ASSERT_EQ(key_paths.size(), encoded_paths.size());
 622   for (size_t i = 0; i < key_paths.size(); ++i) {
 623     IndexedDBKeyPath key_path = key_paths[i];
 624     std::string encoded = encoded_paths[i];
 625
 626     std::string v = WrappedEncodeIDBKeyPath(key_path);
 627     EXPECT_EQ(encoded, v);
 628
 629     StringPiece slice(encoded);
 630     IndexedDBKeyPath decoded;
 631     EXPECT_TRUE(DecodeIDBKeyPath(&slice, &decoded));
 632     EXPECT_EQ(key_path, decoded);
 633     EXPECT_TRUE(slice.empty());
 634   }
 635 }
 636
 637 TEST(IndexedDBLevelDBCodingTest, DecodeLegacyIDBKeyPath) {
 638   // Legacy encoding of string key paths.
 639   std::vector<IndexedDBKeyPath> key_paths;
 640   std::vector<std::string> encoded_paths;
 641
 642   {
 643     key_paths.push_back(IndexedDBKeyPath(string16()));
 644     encoded_paths.push_back(std::string());
 645   }
 646   {
 647     key_paths.push_back(IndexedDBKeyPath(ASCIIToUTF16("foo")));
 648     char expected[] = {0, 'f', 0, 'o', 0, 'o'};
 649     encoded_paths.push_back(std::string(expected, arraysize(expected)));
 650   }
 651   {
 652     key_paths.push_back(IndexedDBKeyPath(ASCIIToUTF16("foo.bar")));
 653     char expected[] = {0, 'f', 0, 'o', 0, 'o', 0, '.', 0, 'b', 0, 'a', 0, 'r'};
 654     encoded_paths.push_back(std::string(expected, arraysize(expected)));
 655   }
 656
 657   ASSERT_EQ(key_paths.size(), encoded_paths.size());
 658   for (size_t i = 0; i < key_paths.size(); ++i) {
 659     IndexedDBKeyPath key_path = key_paths[i];
 660     std::string encoded = encoded_paths[i];
 661
 662     StringPiece slice(encoded);
 663     IndexedDBKeyPath decoded;
 664     EXPECT_TRUE(DecodeIDBKeyPath(&slice, &decoded));
 665     EXPECT_EQ(key_path, decoded);
 666     EXPECT_TRUE(slice.empty());
 667   }
 668 }
 669
 670 TEST(IndexedDBLevelDBCodingTest, ExtractAndCompareIDBKeys) {
 671   std::vector<IndexedDBKey> keys;
 672
 673   keys.push_back(IndexedDBKey(-10, WebIDBKeyTypeNumber));
 674   keys.push_back(IndexedDBKey(0, WebIDBKeyTypeNumber));
 675   keys.push_back(IndexedDBKey(3.14, WebIDBKeyTypeNumber));
 676
 677   keys.push_back(IndexedDBKey(0, WebIDBKeyTypeDate));
 678   keys.push_back(IndexedDBKey(100, WebIDBKeyTypeDate));
 679   keys.push_back(IndexedDBKey(100000, WebIDBKeyTypeDate));
 680
 681   keys.push_back(IndexedDBKey(ASCIIToUTF16("")));
 682   keys.push_back(IndexedDBKey(ASCIIToUTF16("a")));
 683   keys.push_back(IndexedDBKey(ASCIIToUTF16("b")));
 684   keys.push_back(IndexedDBKey(ASCIIToUTF16("baaa")));
 685   keys.push_back(IndexedDBKey(ASCIIToUTF16("baab")));
 686   keys.push_back(IndexedDBKey(ASCIIToUTF16("c")));
 687
 688   keys.push_back(CreateArrayIDBKey());
 689   keys.push_back(CreateArrayIDBKey(IndexedDBKey(0, WebIDBKeyTypeNumber)));
 690   keys.push_back(CreateArrayIDBKey(IndexedDBKey(0, WebIDBKeyTypeNumber),
 691                                    IndexedDBKey(3.14, WebIDBKeyTypeNumber)));
 692   keys.push_back(CreateArrayIDBKey(IndexedDBKey(0, WebIDBKeyTypeDate)));
 693   keys.push_back(CreateArrayIDBKey(IndexedDBKey(0, WebIDBKeyTypeDate),
 694                                    IndexedDBKey(0, WebIDBKeyTypeDate)));
 695   keys.push_back(CreateArrayIDBKey(IndexedDBKey(ASCIIToUTF16(""))));
 696   keys.push_back(CreateArrayIDBKey(IndexedDBKey(ASCIIToUTF16("")),
 697                                    IndexedDBKey(ASCIIToUTF16("a"))));
 698   keys.push_back(CreateArrayIDBKey(CreateArrayIDBKey()));
 699   keys.push_back(CreateArrayIDBKey(CreateArrayIDBKey(), CreateArrayIDBKey()));
 700   keys.push_back(CreateArrayIDBKey(CreateArrayIDBKey(CreateArrayIDBKey())));
 701   keys.push_back(CreateArrayIDBKey(
 702       CreateArrayIDBKey(CreateArrayIDBKey(CreateArrayIDBKey()))));
 703
 704   for (size_t i = 0; i < keys.size() - 1; ++i) {
 705     const IndexedDBKey& key_a = keys[i];
 706     const IndexedDBKey& key_b = keys[i + 1];
 707
 708     EXPECT_TRUE(key_a.IsLessThan(key_b));
 709
 710     std::string encoded_a;
 711     EncodeIDBKey(key_a, &encoded_a);
 712     EXPECT_TRUE(encoded_a.size());
 713     std::string encoded_b;
 714     EncodeIDBKey(key_b, &encoded_b);
 715     EXPECT_TRUE(encoded_b.size());
 716
 717     std::string extracted_a;
 718     std::string extracted_b;
 719     StringPiece slice;
 720
 721     slice = StringPiece(encoded_a);
 722     EXPECT_TRUE(ExtractEncodedIDBKey(&slice, &extracted_a));
 723     EXPECT_TRUE(slice.empty());
 724     EXPECT_EQ(encoded_a, extracted_a);
 725
 726     slice = StringPiece(encoded_b);
 727     EXPECT_TRUE(ExtractEncodedIDBKey(&slice, &extracted_b));
 728     EXPECT_TRUE(slice.empty());
 729     EXPECT_EQ(encoded_b, extracted_b);
 730
 731     EXPECT_LT(CompareKeys(extracted_a, extracted_b), 0);
 732     EXPECT_GT(CompareKeys(extracted_b, extracted_a), 0);
 733     EXPECT_EQ(CompareKeys(extracted_a, extracted_a), 0);
 734     EXPECT_EQ(CompareKeys(extracted_b, extracted_b), 0);
 735
 736     slice = StringPiece(&*encoded_a.begin(), encoded_a.size() - 1);
 737     EXPECT_FALSE(ExtractEncodedIDBKey(&slice, &extracted_a));
 738   }
 739 }
 740
 741 TEST(IndexedDBLevelDBCodingTest, ComparisonTest) {
 742   std::vector<std::string> keys;
 743   keys.push_back(SchemaVersionKey::Encode());
 744   keys.push_back(MaxDatabaseIdKey::Encode());
 745   keys.push_back(DatabaseFreeListKey::Encode(0));
 746   keys.push_back(DatabaseFreeListKey::EncodeMaxKey());
 747   keys.push_back(DatabaseNameKey::Encode("", ASCIIToUTF16("")));
 748   keys.push_back(DatabaseNameKey::Encode("", ASCIIToUTF16("a")));
 749   keys.push_back(DatabaseNameKey::Encode("a", ASCIIToUTF16("a")));
 750   keys.push_back(
 751       DatabaseMetaDataKey::Encode(1, DatabaseMetaDataKey::ORIGIN_NAME));
 752   keys.push_back(
 753       DatabaseMetaDataKey::Encode(1, DatabaseMetaDataKey::DATABASE_NAME));
 754   keys.push_back(
 755       DatabaseMetaDataKey::Encode(1, DatabaseMetaDataKey::USER_VERSION));
 756   keys.push_back(
 757       DatabaseMetaDataKey::Encode(1, DatabaseMetaDataKey::MAX_OBJECT_STORE_ID));
 758   keys.push_back(
 759       DatabaseMetaDataKey::Encode(1, DatabaseMetaDataKey::USER_INT_VERSION));
 760   keys.push_back(
 761       ObjectStoreMetaDataKey::Encode(1, 1, ObjectStoreMetaDataKey::NAME));
 762   keys.push_back(
 763       ObjectStoreMetaDataKey::Encode(1, 1, ObjectStoreMetaDataKey::KEY_PATH));
 764   keys.push_back(ObjectStoreMetaDataKey::Encode(
 765       1, 1, ObjectStoreMetaDataKey::AUTO_INCREMENT));
 766   keys.push_back(
 767       ObjectStoreMetaDataKey::Encode(1, 1, ObjectStoreMetaDataKey::EVICTABLE));
 768   keys.push_back(ObjectStoreMetaDataKey::Encode(
 769       1, 1, ObjectStoreMetaDataKey::LAST_VERSION));
 770   keys.push_back(ObjectStoreMetaDataKey::Encode(
 771       1, 1, ObjectStoreMetaDataKey::MAX_INDEX_ID));
 772   keys.push_back(ObjectStoreMetaDataKey::Encode(
 773       1, 1, ObjectStoreMetaDataKey::HAS_KEY_PATH));
 774   keys.push_back(ObjectStoreMetaDataKey::Encode(
 775       1, 1, ObjectStoreMetaDataKey::KEY_GENERATOR_CURRENT_NUMBER));
 776   keys.push_back(ObjectStoreMetaDataKey::EncodeMaxKey(1, 1));
 777   keys.push_back(ObjectStoreMetaDataKey::EncodeMaxKey(1, 2));
 778   keys.push_back(ObjectStoreMetaDataKey::EncodeMaxKey(1));
 779   keys.push_back(IndexMetaDataKey::Encode(1, 1, 30, IndexMetaDataKey::NAME));
 780   keys.push_back(IndexMetaDataKey::Encode(1, 1, 30, IndexMetaDataKey::UNIQUE));
 781   keys.push_back(
 782       IndexMetaDataKey::Encode(1, 1, 30, IndexMetaDataKey::KEY_PATH));
 783   keys.push_back(
 784       IndexMetaDataKey::Encode(1, 1, 30, IndexMetaDataKey::MULTI_ENTRY));
 785   keys.push_back(IndexMetaDataKey::Encode(1, 1, 31, 0));
 786   keys.push_back(IndexMetaDataKey::Encode(1, 1, 31, 1));
 787   keys.push_back(IndexMetaDataKey::EncodeMaxKey(1, 1, 31));
 788   keys.push_back(IndexMetaDataKey::EncodeMaxKey(1, 1, 32));
 789   keys.push_back(IndexMetaDataKey::EncodeMaxKey(1, 1));
 790   keys.push_back(IndexMetaDataKey::EncodeMaxKey(1, 2));
 791   keys.push_back(ObjectStoreFreeListKey::Encode(1, 1));
 792   keys.push_back(ObjectStoreFreeListKey::EncodeMaxKey(1));
 793   keys.push_back(IndexFreeListKey::Encode(1, 1, kMinimumIndexId));
 794   keys.push_back(IndexFreeListKey::EncodeMaxKey(1, 1));
 795   keys.push_back(IndexFreeListKey::Encode(1, 2, kMinimumIndexId));
 796   keys.push_back(IndexFreeListKey::EncodeMaxKey(1, 2));
 797   keys.push_back(ObjectStoreNamesKey::Encode(1, ASCIIToUTF16("")));
 798   keys.push_back(ObjectStoreNamesKey::Encode(1, ASCIIToUTF16("a")));
 799   keys.push_back(IndexNamesKey::Encode(1, 1, ASCIIToUTF16("")));
 800   keys.push_back(IndexNamesKey::Encode(1, 1, ASCIIToUTF16("a")));
 801   keys.push_back(IndexNamesKey::Encode(1, 2, ASCIIToUTF16("a")));
 802   keys.push_back(ObjectStoreDataKey::Encode(1, 1, std::string()));
 803   keys.push_back(ObjectStoreDataKey::Encode(1, 1, MinIDBKey()));
 804   keys.push_back(ObjectStoreDataKey::Encode(1, 1, MaxIDBKey()));
 805   keys.push_back(ExistsEntryKey::Encode(1, 1, std::string()));
 806   keys.push_back(ExistsEntryKey::Encode(1, 1, MinIDBKey()));
 807   keys.push_back(ExistsEntryKey::Encode(1, 1, MaxIDBKey()));
 808   keys.push_back(IndexDataKey::Encode(1, 1, 30, MinIDBKey(), std::string(), 0));
 809   keys.push_back(IndexDataKey::Encode(1, 1, 30, MinIDBKey(), MinIDBKey(), 0));
 810   keys.push_back(IndexDataKey::Encode(1, 1, 30, MinIDBKey(), MinIDBKey(), 1));
 811   keys.push_back(IndexDataKey::Encode(1, 1, 30, MinIDBKey(), MaxIDBKey(), 0));
 812   keys.push_back(IndexDataKey::Encode(1, 1, 30, MinIDBKey(), MaxIDBKey(), 1));
 813   keys.push_back(IndexDataKey::Encode(1, 1, 30, MaxIDBKey(), MinIDBKey(), 0));
 814   keys.push_back(IndexDataKey::Encode(1, 1, 30, MaxIDBKey(), MinIDBKey(), 1));
 815   keys.push_back(IndexDataKey::Encode(1, 1, 30, MaxIDBKey(), MaxIDBKey(), 0));
 816   keys.push_back(IndexDataKey::Encode(1, 1, 30, MaxIDBKey(), MaxIDBKey(), 1));
 817   keys.push_back(IndexDataKey::Encode(1, 1, 31, MinIDBKey(), MinIDBKey(), 0));
 818   keys.push_back(IndexDataKey::Encode(1, 2, 30, MinIDBKey(), MinIDBKey(), 0));
 819   keys.push_back(
 820       IndexDataKey::EncodeMaxKey(1, 2, std::numeric_limits<int32>::max() - 1));
 821
 822   for (size_t i = 0; i < keys.size(); ++i) {
 823     EXPECT_EQ(Compare(keys[i], keys[i], false), 0);
 824
 825     for (size_t j = i + 1; j < keys.size(); ++j) {
 826       EXPECT_LT(Compare(keys[i], keys[j], false), 0);
 827       EXPECT_GT(Compare(keys[j], keys[i], false), 0);
 828     }
 829   }
 830 }
 831
 832 TEST(IndexedDBLevelDBCodingTest, EncodeVarIntVSEncodeByteTest) {
 833   std::vector<unsigned char> test_cases;
 834   test_cases.push_back(0);
 835   test_cases.push_back(1);
 836   test_cases.push_back(127);
 837
 838   for (size_t i = 0; i < test_cases.size(); ++i) {
 839     unsigned char n = test_cases[i];
 840
 841     std::string vA = WrappedEncodeByte(n);
 842     std::string vB = WrappedEncodeVarInt(static_cast<int64>(n));
 843
 844     EXPECT_EQ(vA.size(), vB.size());
 845     EXPECT_EQ(*vA.begin(), *vB.begin());
 846   }
 847 }
 848
 849 }  // namespace
 850
 851 }  // namespace content