code.vuplus.com Git - vuplus_webkit/blob - Source/WebKit/chromium/tests/IDBLevelDBCodingTest.cpp

   1 /*
   2  * Copyright (C) 2011 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "IDBLevelDBCoding.h"
  28
  29 #if ENABLE(INDEXED_DATABASE)
  30 #if ENABLE(LEVELDB)
  31
  32 #include "IDBKey.h"
  33 #include "LevelDBSlice.h"
  34 #include <gtest/gtest.h>
  35 #include <wtf/Vector.h>
  36
  37 using namespace WebCore;
  38 using namespace IDBLevelDBCoding;
  39
  40 namespace {
  41
  42 TEST(IDBLevelDBCodingTest, EncodeByte)
  43 {
  44     Vector<char> expected;
  45     expected.append(0);
  46     unsigned char c;
  47
  48     c = 0;
  49     expected[0] = c;
  50     EXPECT_EQ(expected, encodeByte(c));
  51
  52     c = 1;
  53     expected[0] = c;
  54     EXPECT_EQ(expected, encodeByte(c));
  55
  56     c = 255;
  57     expected[0] = c;
  58     EXPECT_EQ(expected, encodeByte(c));
  59 }
  60
  61 TEST(IDBLevelDBCodingTest, MaxIDBKey)
  62 {
  63     Vector<char> maxKey = maxIDBKey();
  64
  65     Vector<char> minKey = minIDBKey();
  66     Vector<char> stringKey = encodeIDBKey(*IDBKey::createString("Hello world"));
  67     Vector<char> numberKey = encodeIDBKey(*IDBKey::createNumber(3.14));
  68     Vector<char> dateKey = encodeIDBKey(*IDBKey::createDate(1000000));
  69
  70     EXPECT_GT(compareEncodedIDBKeys(maxKey, minKey), 0);
  71     EXPECT_GT(compareEncodedIDBKeys(maxKey, stringKey), 0);
  72     EXPECT_GT(compareEncodedIDBKeys(maxKey, numberKey), 0);
  73     EXPECT_GT(compareEncodedIDBKeys(maxKey, dateKey), 0);
  74 }
  75
  76 TEST(IDBLevelDBCodingTest, MinIDBKey)
  77 {
  78     Vector<char> minKey = minIDBKey();
  79
  80     Vector<char> maxKey = maxIDBKey();
  81     Vector<char> stringKey = encodeIDBKey(*IDBKey::createString("Hello world"));
  82     Vector<char> numberKey = encodeIDBKey(*IDBKey::createNumber(3.14));
  83     Vector<char> dateKey = encodeIDBKey(*IDBKey::createDate(1000000));
  84
  85     EXPECT_LT(compareEncodedIDBKeys(minKey, maxKey), 0);
  86     EXPECT_LT(compareEncodedIDBKeys(minKey, stringKey), 0);
  87     EXPECT_LT(compareEncodedIDBKeys(minKey, numberKey), 0);
  88     EXPECT_LT(compareEncodedIDBKeys(minKey, dateKey), 0);
  89 }
  90
  91 TEST(IDBLevelDBCodingTest, EncodeInt)
  92 {
  93     EXPECT_EQ(static_cast<size_t>(1), encodeInt(0).size());
  94     EXPECT_EQ(static_cast<size_t>(1), encodeInt(1).size());
  95     EXPECT_EQ(static_cast<size_t>(1), encodeInt(255).size());
  96     EXPECT_EQ(static_cast<size_t>(2), encodeInt(256).size());
  97     EXPECT_EQ(static_cast<size_t>(4), encodeInt(0xffffffff).size());
  98 }
  99
 100 TEST(IDBLevelDBCodingTest, DecodeInt)
 101 {
 102     Vector<int64_t> testCases;
 103     testCases.append(0);
 104     testCases.append(1);
 105     testCases.append(255);
 106     testCases.append(256);
 107     testCases.append(65535);
 108     testCases.append(655536);
 109     testCases.append(7711192431755665792ll);
 110     testCases.append(0x7fffffffffffffffll);
 111
 112     for (size_t i = 0; i < testCases.size(); ++i) {
 113         int64_t n = testCases[i];
 114         Vector<char> v = encodeInt(n);
 115         EXPECT_EQ(n, decodeInt(v.data(), v.data() + v.size()));
 116     }
 117 }
 118
 119 TEST(IDBLevelDBCodingTest, EncodeVarInt)
 120 {
 121     EXPECT_EQ(static_cast<size_t>(1), encodeVarInt(0).size());
 122     EXPECT_EQ(static_cast<size_t>(1), encodeVarInt(1).size());
 123     EXPECT_EQ(static_cast<size_t>(2), encodeVarInt(255).size());
 124     EXPECT_EQ(static_cast<size_t>(2), encodeVarInt(256).size());
 125     EXPECT_EQ(static_cast<size_t>(5), encodeVarInt(0xffffffff).size());
 126 }
 127
 128 TEST(IDBLevelDBCodingTest, DecodeVarInt)
 129 {
 130     Vector<int64_t> testCases;
 131     testCases.append(0);
 132     testCases.append(1);
 133     testCases.append(255);
 134     testCases.append(256);
 135     testCases.append(65535);
 136     testCases.append(655536);
 137     testCases.append(7711192431755665792ll);
 138     testCases.append(0x7fffffffffffffffll);
 139
 140     for (size_t i = 0; i < testCases.size(); ++i) {
 141         int64_t n = testCases[i];
 142         Vector<char> v = encodeVarInt(n);
 143
 144         int64_t res;
 145         const char* p = decodeVarInt(v.data(), v.data() + v.size(), res);
 146         EXPECT_EQ(n, res);
 147         EXPECT_EQ(v.data() + v.size(), p);
 148
 149         p = decodeVarInt(v.data(), v.data() + v.size() - 1, res);
 150         EXPECT_EQ(0, p);
 151         p = decodeVarInt(v.data(), v.data(), res);
 152         EXPECT_EQ(0, p);
 153     }
 154 }
 155
 156 TEST(IDBLevelDBCodingTest, EncodeString)
 157 {
 158     const UChar testStringA[] = {'f', 'o', 'o', '\0'};
 159     const UChar testStringB[] = {0xdead, 0xbeef, '\0'};
 160
 161     EXPECT_EQ(static_cast<size_t>(0), encodeString(String("")).size());
 162     EXPECT_EQ(static_cast<size_t>(2), encodeString(String("a")).size());
 163     EXPECT_EQ(static_cast<size_t>(6), encodeString(String("foo")).size());
 164     EXPECT_EQ(static_cast<size_t>(6), encodeString(String(testStringA)).size());
 165     EXPECT_EQ(static_cast<size_t>(4), encodeString(String(testStringB)).size());
 166 }
 167
 168 TEST(IDBLevelDBCodingTest, DecodeString)
 169 {
 170     const UChar testStringA[] = {'f', 'o', 'o', '\0'};
 171     const UChar testStringB[] = {0xdead, 0xbeef, '\0'};
 172     Vector<char> v;
 173
 174     v = encodeString(String(""));
 175     EXPECT_EQ(String(""), decodeString(v.data(), v.data() + v.size()));
 176
 177     v = encodeString(String("a"));
 178     EXPECT_EQ(String("a"), decodeString(v.data(), v.data() + v.size()));
 179
 180     v = encodeString(String("foo"));
 181     EXPECT_EQ(String("foo"), decodeString(v.data(), v.data() + v.size()));
 182
 183     v = encodeString(String(testStringA));
 184     EXPECT_EQ(String(testStringA), decodeString(v.data(), v.data() + v.size()));
 185
 186     v = encodeString(String(testStringB));
 187     EXPECT_EQ(String(testStringB), decodeString(v.data(), v.data() + v.size()));
 188 }
 189
 190 TEST(IDBLevelDBCodingTest, EncodeStringWithLength)
 191 {
 192     const UChar testStringA[] = {'f', 'o', 'o', '\0'};
 193     const UChar testStringB[] = {0xdead, 0xbeef, '\0'};
 194
 195     EXPECT_EQ(static_cast<size_t>(1), encodeStringWithLength(String("")).size());
 196     EXPECT_EQ(static_cast<size_t>(3), encodeStringWithLength(String("a")).size());
 197     EXPECT_EQ(static_cast<size_t>(7), encodeStringWithLength(String(testStringA)).size());
 198     EXPECT_EQ(static_cast<size_t>(5), encodeStringWithLength(String(testStringB)).size());
 199 }
 200
 201 TEST(IDBLevelDBCodingTest, DecodeStringWithLength)
 202 {
 203     const UChar testStringA[] = {'f', 'o', 'o', '\0'};
 204     const UChar testStringB[] = {0xdead, 0xbeef, '\0'};
 205
 206     const int kLongStringLen = 1234;
 207     UChar longString[kLongStringLen + 1];
 208     for (int i = 0; i < kLongStringLen; ++i)
 209         longString[i] = i;
 210     longString[kLongStringLen] = 0;
 211
 212     Vector<String> testCases;
 213     testCases.append(String(""));
 214     testCases.append(String("a"));
 215     testCases.append(String("foo"));
 216     testCases.append(String(testStringA));
 217     testCases.append(String(testStringB));
 218     testCases.append(String(longString));
 219
 220     for (size_t i = 0; i < testCases.size(); ++i) {
 221         String s = testCases[i];
 222         Vector<char> v = encodeStringWithLength(s);
 223         String res;
 224         const char* p = decodeStringWithLength(v.data(), v.data() + v.size(), res);
 225         EXPECT_EQ(s, res);
 226         EXPECT_EQ(v.data() + v.size(), p);
 227
 228         EXPECT_EQ(0, decodeStringWithLength(v.data(), v.data() + v.size() - 1, res));
 229         EXPECT_EQ(0, decodeStringWithLength(v.data(), v.data(), res));
 230     }
 231 }
 232
 233 TEST(IDBLevelDBCodingTest, EncodeDouble)
 234 {
 235     EXPECT_EQ(static_cast<size_t>(8), encodeDouble(0).size());
 236     EXPECT_EQ(static_cast<size_t>(8), encodeDouble(3.14).size());
 237 }
 238
 239 TEST(IDBLevelDBCodingTest, DecodeDouble)
 240 {
 241     Vector<char> v;
 242     const char* p;
 243     double d;
 244
 245     v = encodeDouble(3.14);
 246     p = decodeDouble(v.data(), v.data() + v.size(), &d);
 247     EXPECT_EQ(3.14, d);
 248     EXPECT_EQ(v.data() + v.size(), p);
 249
 250     v = encodeDouble(-3.14);
 251     p = decodeDouble(v.data(), v.data() + v.size(), &d);
 252     EXPECT_EQ(-3.14, d);
 253     EXPECT_EQ(v.data() + v.size(), p);
 254
 255     v = encodeDouble(3.14);
 256     p = decodeDouble(v.data(), v.data() + v.size() - 1, &d);
 257     EXPECT_EQ(0, p);
 258 }
 259
 260 TEST(IDBLevelDBCodingTest, EncodeDecodeIDBKey)
 261 {
 262     RefPtr<IDBKey> expectedKey;
 263     RefPtr<IDBKey> decodedKey;
 264     Vector<char> v;
 265     const char* p;
 266
 267     expectedKey = IDBKey::createNumber(1234);
 268     v = encodeIDBKey(*expectedKey);
 269     p = decodeIDBKey(v.data(), v.data() + v.size(), decodedKey);
 270     EXPECT_TRUE(decodedKey->isEqual(expectedKey.get()));
 271     EXPECT_EQ(v.data() + v.size(), p);
 272     EXPECT_EQ(0, decodeIDBKey(v.data(), v.data() + v.size() - 1, decodedKey));
 273
 274     expectedKey = IDBKey::createString("Hello World!");
 275     v = encodeIDBKey(*expectedKey);
 276     p = decodeIDBKey(v.data(), v.data() + v.size(), decodedKey);
 277     EXPECT_TRUE(decodedKey->isEqual(expectedKey.get()));
 278     EXPECT_EQ(v.data() + v.size(), p);
 279     EXPECT_EQ(0, decodeIDBKey(v.data(), v.data() + v.size() - 1, decodedKey));
 280
 281     expectedKey = IDBKey::createDate(7890);
 282     v = encodeIDBKey(*expectedKey);
 283     p = decodeIDBKey(v.data(), v.data() + v.size(), decodedKey);
 284     EXPECT_TRUE(decodedKey->isEqual(expectedKey.get()));
 285     EXPECT_EQ(v.data() + v.size(), p);
 286     EXPECT_EQ(0, decodeIDBKey(v.data(), v.data() + v.size() - 1, decodedKey));
 287 }
 288
 289 TEST(IDBLevelDBCodingTest, ExtractAndCompareIDBKeys)
 290 {
 291     Vector<RefPtr<IDBKey> > keys;
 292
 293     keys.append(IDBKey::createNumber(-10));
 294     keys.append(IDBKey::createNumber(0));
 295     keys.append(IDBKey::createNumber(3.14));
 296
 297     keys.append(IDBKey::createDate(0));
 298     keys.append(IDBKey::createDate(100));
 299     keys.append(IDBKey::createDate(100000));
 300
 301     keys.append(IDBKey::createString(""));
 302     keys.append(IDBKey::createString("a"));
 303     keys.append(IDBKey::createString("b"));
 304     keys.append(IDBKey::createString("baaa"));
 305
 306     for (size_t i = 0; i < keys.size() - 1; ++i) {
 307         RefPtr<IDBKey> keyA = keys[i];
 308         RefPtr<IDBKey> keyB = keys[i + 1];
 309
 310         EXPECT_TRUE(keyA->isLessThan(keyB.get()));
 311
 312         Vector<char> encodedA = encodeIDBKey(*keyA);
 313         EXPECT_TRUE(encodedA.size());
 314         Vector<char> encodedB = encodeIDBKey(*keyB);
 315         EXPECT_TRUE(encodedB.size());
 316
 317         Vector<char> extractedA;
 318         Vector<char> extractedB;
 319
 320         const char* p = extractEncodedIDBKey(encodedA.data(), encodedA.data() + encodedA.size(), &extractedA);
 321         EXPECT_EQ(encodedA.data() + encodedA.size(), p);
 322         EXPECT_EQ(encodedA, extractedA);
 323
 324         const char* q = extractEncodedIDBKey(encodedB.data(), encodedB.data() + encodedB.size(), &extractedB);
 325         EXPECT_EQ(encodedB.data() + encodedB.size(), q);
 326         EXPECT_EQ(encodedB, extractedB);
 327
 328         EXPECT_LT(compareEncodedIDBKeys(extractedA, extractedB), 0);
 329         EXPECT_GT(compareEncodedIDBKeys(extractedB, extractedA), 0);
 330         EXPECT_EQ(compareEncodedIDBKeys(extractedA, extractedA), 0);
 331         EXPECT_EQ(compareEncodedIDBKeys(extractedB, extractedB), 0);
 332
 333         EXPECT_EQ(0, extractEncodedIDBKey(encodedA.data(), encodedA.data() + encodedA.size() - 1, &extractedA));
 334     }
 335 }
 336
 337 TEST(IDBLevelDBCodingTest, ComparisonTest)
 338 {
 339     Vector<Vector<char> > keys;
 340     keys.append(SchemaVersionKey::encode());
 341     keys.append(MaxDatabaseIdKey::encode());
 342     keys.append(DatabaseFreeListKey::encode(0));
 343     keys.append(DatabaseFreeListKey::encodeMaxKey());
 344     keys.append(DatabaseNameKey::encode("", ""));
 345     keys.append(DatabaseNameKey::encode("", "a"));
 346     keys.append(DatabaseNameKey::encode("a", "a"));
 347     keys.append(DatabaseMetaDataKey::encode(1, DatabaseMetaDataKey::kOriginName));
 348     keys.append(ObjectStoreMetaDataKey::encode(1, 1, 0));
 349     keys.append(ObjectStoreMetaDataKey::encodeMaxKey(1));
 350     keys.append(IndexMetaDataKey::encode(1, 1, 30, 0));
 351     keys.append(IndexMetaDataKey::encode(1, 1, 31, 0));
 352     keys.append(IndexMetaDataKey::encode(1, 1, 31, 1));
 353     keys.append(ObjectStoreFreeListKey::encode(1, 1));
 354     keys.append(ObjectStoreFreeListKey::encodeMaxKey(1));
 355     keys.append(IndexFreeListKey::encode(1, 1, kMinimumIndexId));
 356     keys.append(IndexFreeListKey::encodeMaxKey(1, 1));
 357     keys.append(IndexFreeListKey::encode(1, 2, kMinimumIndexId));
 358     keys.append(IndexFreeListKey::encodeMaxKey(1, 2));
 359     keys.append(ObjectStoreNamesKey::encode(1, ""));
 360     keys.append(ObjectStoreNamesKey::encode(1, "a"));
 361     keys.append(IndexNamesKey::encode(1, 1, ""));
 362     keys.append(IndexNamesKey::encode(1, 1, "a"));
 363     keys.append(IndexNamesKey::encode(1, 2, "a"));
 364     keys.append(ObjectStoreDataKey::encode(1, 1, minIDBKey()));
 365     keys.append(ObjectStoreDataKey::encode(1, 1, maxIDBKey()));
 366     keys.append(ExistsEntryKey::encode(1, 1, minIDBKey()));
 367     keys.append(ExistsEntryKey::encode(1, 1, maxIDBKey()));
 368     keys.append(IndexDataKey::encode(1, 1, 30, minIDBKey(), 0));
 369     keys.append(IndexDataKey::encode(1, 1, 30, minIDBKey(), 1));
 370     keys.append(IndexDataKey::encode(1, 1, 30, maxIDBKey(), 0));
 371     keys.append(IndexDataKey::encode(1, 1, 30, maxIDBKey(), 1));
 372     keys.append(IndexDataKey::encode(1, 1, 31, minIDBKey(), 0));
 373     keys.append(IndexDataKey::encode(1, 2, 30, minIDBKey(), 0));
 374     keys.append(IndexDataKey::encodeMaxKey(1, 2));
 375
 376     for (size_t i = 0; i < keys.size(); ++i) {
 377         const LevelDBSlice keyA(keys[i]);
 378         EXPECT_EQ(compare(keyA, keyA), 0);
 379
 380         for (size_t j = i + 1; j < keys.size(); ++j) {
 381             const LevelDBSlice keyB(keys[j]);
 382             EXPECT_LT(compare(keyA, keyB), 0);
 383             EXPECT_GT(compare(keyB, keyA), 0);
 384         }
 385     }
 386 }
 387
 388 } // namespace
 389
 390 #endif // ENABLE(LEVELDB)
 391 #endif // ENABLE(INDEXED_DATABASE)