eb2cc2af99330a3918a67c460fc27fca16d1400e
[WebKit-https.git] / 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 USE(LEVELDB)
31
32 #include "IDBKey.h"
33 #include "IDBKeyPath.h"
34 #include "LevelDBSlice.h"
35 #include <gtest/gtest.h>
36 #include <wtf/Vector.h>
37
38 using namespace WebCore;
39 using namespace IDBLevelDBCoding;
40
41 namespace {
42
43 static PassRefPtr<IDBKey> createArrayIDBKey()
44 {
45     return IDBKey::createArray(IDBKey::KeyArray());
46 }
47
48 static PassRefPtr<IDBKey> createArrayIDBKey(PassRefPtr<IDBKey> prpKey1)
49 {
50     RefPtr<IDBKey> key1 = prpKey1;
51
52     IDBKey::KeyArray array;
53     array.append(key1);
54     return IDBKey::createArray(array);
55 }
56
57 static PassRefPtr<IDBKey> createArrayIDBKey(PassRefPtr<IDBKey> prpKey1, PassRefPtr<IDBKey> prpKey2)
58 {
59     RefPtr<IDBKey> key1 = prpKey1;
60     RefPtr<IDBKey> key2 = prpKey2;
61
62     IDBKey::KeyArray array;
63     array.append(key1);
64     array.append(key2);
65     return IDBKey::createArray(array);
66 }
67
68 TEST(IDBLevelDBCodingTest, EncodeByte)
69 {
70     Vector<char> expected;
71     expected.append(0);
72     unsigned char c;
73
74     c = 0;
75     expected[0] = c;
76     EXPECT_EQ(expected, encodeByte(c));
77
78     c = 1;
79     expected[0] = c;
80     EXPECT_EQ(expected, encodeByte(c));
81
82     c = 255;
83     expected[0] = c;
84     EXPECT_EQ(expected, encodeByte(c));
85 }
86
87 TEST(IDBLevelDBCodingTest, DecodeByte)
88 {
89     Vector<unsigned char> testCases;
90     testCases.append(0);
91     testCases.append(1);
92     testCases.append(255);
93
94     for (size_t i = 0; i < testCases.size(); ++i) {
95         unsigned char n = testCases[i];
96         Vector<char> v = encodeByte(n);
97
98         unsigned char res;
99         const char* p = decodeByte(v.data(), v.data() + v.size(), res);
100         EXPECT_EQ(n, res);
101         EXPECT_EQ(v.data() + v.size(), p);
102     }
103 }
104    
105 TEST(IDBLevelDBCodingTest, EncodeBool)
106 {
107     {
108         Vector<char> expected;
109         expected.append(1);
110         EXPECT_EQ(expected, encodeBool(true));
111     }
112     {
113         Vector<char> expected;
114         expected.append(0);
115         EXPECT_EQ(expected, encodeBool(false));
116     }
117 }
118
119 static int compareKeys(const Vector<char>& a, const Vector<char>& b)
120 {
121     bool ok;
122     int result = compareEncodedIDBKeys(a, b, ok);
123     EXPECT_TRUE(ok);
124     return result;
125 }
126
127 TEST(IDBLevelDBCodingTest, MaxIDBKey)
128 {
129     Vector<char> maxKey = maxIDBKey();
130
131     Vector<char> minKey = minIDBKey();
132     Vector<char> arrayKey = encodeIDBKey(*IDBKey::createArray(IDBKey::KeyArray()));
133     Vector<char> stringKey = encodeIDBKey(*IDBKey::createString("Hello world"));
134     Vector<char> numberKey = encodeIDBKey(*IDBKey::createNumber(3.14));
135     Vector<char> dateKey = encodeIDBKey(*IDBKey::createDate(1000000));
136
137     EXPECT_GT(compareKeys(maxKey, minKey), 0);
138     EXPECT_GT(compareKeys(maxKey, arrayKey), 0);
139     EXPECT_GT(compareKeys(maxKey, stringKey), 0);
140     EXPECT_GT(compareKeys(maxKey, numberKey), 0);
141     EXPECT_GT(compareKeys(maxKey, dateKey), 0);
142 }
143
144 TEST(IDBLevelDBCodingTest, MinIDBKey)
145 {
146     Vector<char> minKey = minIDBKey();
147
148     Vector<char> maxKey = maxIDBKey();
149     Vector<char> arrayKey = encodeIDBKey(*IDBKey::createArray(IDBKey::KeyArray()));
150     Vector<char> stringKey = encodeIDBKey(*IDBKey::createString("Hello world"));
151     Vector<char> numberKey = encodeIDBKey(*IDBKey::createNumber(3.14));
152     Vector<char> dateKey = encodeIDBKey(*IDBKey::createDate(1000000));
153
154     EXPECT_LT(compareKeys(minKey, maxKey), 0);
155     EXPECT_LT(compareKeys(minKey, arrayKey), 0);
156     EXPECT_LT(compareKeys(minKey, stringKey), 0);
157     EXPECT_LT(compareKeys(minKey, numberKey), 0);
158     EXPECT_LT(compareKeys(minKey, dateKey), 0);
159 }
160
161 TEST(IDBLevelDBCodingTest, EncodeInt)
162 {
163     EXPECT_EQ(static_cast<size_t>(1), encodeInt(0).size());
164     EXPECT_EQ(static_cast<size_t>(1), encodeInt(1).size());
165     EXPECT_EQ(static_cast<size_t>(1), encodeInt(255).size());
166     EXPECT_EQ(static_cast<size_t>(2), encodeInt(256).size());
167     EXPECT_EQ(static_cast<size_t>(4), encodeInt(0xffffffff).size());
168 #ifdef NDEBUG
169     EXPECT_EQ(static_cast<size_t>(8), encodeInt(-1).size());
170 #endif
171 }
172
173 TEST(IDBLevelDBCodingTest, DecodeBool)
174 {
175     {
176         Vector<char> encoded;
177         encoded.append(1);
178         EXPECT_TRUE(decodeBool(encoded.data(), encoded.data() + encoded.size()));
179     }
180     {
181         Vector<char> encoded;
182         encoded.append(0);
183         EXPECT_FALSE(decodeBool(encoded.data(), encoded.data() + encoded.size()));
184     }
185 }
186
187 TEST(IDBLevelDBCodingTest, DecodeInt)
188 {
189     Vector<int64_t> testCases;
190     testCases.append(0);
191     testCases.append(1);
192     testCases.append(255);
193     testCases.append(256);
194     testCases.append(65535);
195     testCases.append(655536);
196     testCases.append(7711192431755665792ll);
197     testCases.append(0x7fffffffffffffffll);
198 #ifdef NDEBUG
199     testCases.append(-3);
200 #endif
201
202     for (size_t i = 0; i < testCases.size(); ++i) {
203         int64_t n = testCases[i];
204         Vector<char> v = encodeInt(n);
205         EXPECT_EQ(n, decodeInt(v.data(), v.data() + v.size()));
206     }
207 }
208
209 TEST(IDBLevelDBCodingTest, EncodeVarInt)
210 {
211     EXPECT_EQ(static_cast<size_t>(1), encodeVarInt(0).size());
212     EXPECT_EQ(static_cast<size_t>(1), encodeVarInt(1).size());
213     EXPECT_EQ(static_cast<size_t>(2), encodeVarInt(255).size());
214     EXPECT_EQ(static_cast<size_t>(2), encodeVarInt(256).size());
215     EXPECT_EQ(static_cast<size_t>(5), encodeVarInt(0xffffffff).size());
216     EXPECT_EQ(static_cast<size_t>(8), encodeVarInt(0xfffffffffffffLL).size());
217     EXPECT_EQ(static_cast<size_t>(9), encodeVarInt(0x7fffffffffffffffLL).size());
218 #ifdef NDEBUG
219     EXPECT_EQ(static_cast<size_t>(10), encodeVarInt(-100).size());
220 #endif
221 }
222
223 TEST(IDBLevelDBCodingTest, DecodeVarInt)
224 {
225     Vector<int64_t> testCases;
226     testCases.append(0);
227     testCases.append(1);
228     testCases.append(255);
229     testCases.append(256);
230     testCases.append(65535);
231     testCases.append(655536);
232     testCases.append(7711192431755665792ll);
233     testCases.append(0x7fffffffffffffffll);
234 #ifdef NDEBUG
235     testCases.append(-3);
236 #endif
237
238     for (size_t i = 0; i < testCases.size(); ++i) {
239         int64_t n = testCases[i];
240         Vector<char> v = encodeVarInt(n);
241
242         int64_t res;
243         const char* p = decodeVarInt(v.data(), v.data() + v.size(), res);
244         EXPECT_EQ(n, res);
245         EXPECT_EQ(v.data() + v.size(), p);
246
247         p = decodeVarInt(v.data(), v.data() + v.size() - 1, res);
248         EXPECT_EQ(0, p);
249         p = decodeVarInt(v.data(), v.data(), res);
250         EXPECT_EQ(0, p);
251     }
252 }
253
254 TEST(IDBLevelDBCodingTest, EncodeString)
255 {
256     const UChar testStringA[] = {'f', 'o', 'o', '\0'};
257     const UChar testStringB[] = {0xdead, 0xbeef, '\0'};
258
259     EXPECT_EQ(static_cast<size_t>(0), encodeString(String("")).size());
260     EXPECT_EQ(static_cast<size_t>(2), encodeString(String("a")).size());
261     EXPECT_EQ(static_cast<size_t>(6), encodeString(String("foo")).size());
262     EXPECT_EQ(static_cast<size_t>(6), encodeString(String(testStringA)).size());
263     EXPECT_EQ(static_cast<size_t>(4), encodeString(String(testStringB)).size());
264 }
265
266 TEST(IDBLevelDBCodingTest, DecodeString)
267 {
268     const UChar testStringA[] = {'f', 'o', 'o', '\0'};
269     const UChar testStringB[] = {0xdead, 0xbeef, '\0'};
270     Vector<char> v;
271
272     v = encodeString(String(""));
273     EXPECT_EQ(String(""), decodeString(v.data(), v.data() + v.size()));
274
275     v = encodeString(String("a"));
276     EXPECT_EQ(String("a"), decodeString(v.data(), v.data() + v.size()));
277
278     v = encodeString(String("foo"));
279     EXPECT_EQ(String("foo"), decodeString(v.data(), v.data() + v.size()));
280
281     v = encodeString(String(testStringA));
282     EXPECT_EQ(String(testStringA), decodeString(v.data(), v.data() + v.size()));
283
284     v = encodeString(String(testStringB));
285     EXPECT_EQ(String(testStringB), decodeString(v.data(), v.data() + v.size()));
286 }
287
288 TEST(IDBLevelDBCodingTest, EncodeStringWithLength)
289 {
290     const UChar testStringA[] = {'f', 'o', 'o', '\0'};
291     const UChar testStringB[] = {0xdead, 0xbeef, '\0'};
292
293     EXPECT_EQ(static_cast<size_t>(1), encodeStringWithLength(String("")).size());
294     EXPECT_EQ(static_cast<size_t>(3), encodeStringWithLength(String("a")).size());
295     EXPECT_EQ(static_cast<size_t>(7), encodeStringWithLength(String(testStringA)).size());
296     EXPECT_EQ(static_cast<size_t>(5), encodeStringWithLength(String(testStringB)).size());
297 }
298
299 TEST(IDBLevelDBCodingTest, DecodeStringWithLength)
300 {
301     const UChar testStringA[] = {'f', 'o', 'o', '\0'};
302     const UChar testStringB[] = {0xdead, 0xbeef, '\0'};
303
304     const int kLongStringLen = 1234;
305     UChar longString[kLongStringLen + 1];
306     for (int i = 0; i < kLongStringLen; ++i)
307         longString[i] = i;
308     longString[kLongStringLen] = 0;
309
310     Vector<String> testCases;
311     testCases.append(String(""));
312     testCases.append(String("a"));
313     testCases.append(String("foo"));
314     testCases.append(String(testStringA));
315     testCases.append(String(testStringB));
316     testCases.append(String(longString));
317
318     for (size_t i = 0; i < testCases.size(); ++i) {
319         String s = testCases[i];
320         Vector<char> v = encodeStringWithLength(s);
321         String res;
322         const char* p = decodeStringWithLength(v.data(), v.data() + v.size(), res);
323         EXPECT_EQ(s, res);
324         EXPECT_EQ(v.data() + v.size(), p);
325
326         EXPECT_EQ(0, decodeStringWithLength(v.data(), v.data() + v.size() - 1, res));
327         EXPECT_EQ(0, decodeStringWithLength(v.data(), v.data(), res));
328     }
329 }
330
331 static int compareStrings(const char* p, const char* limitP, const char* q, const char* limitQ)
332 {
333     bool ok;
334     int result = compareEncodedStringsWithLength(p, limitP, q, limitQ, ok);
335     EXPECT_TRUE(ok);
336     EXPECT_EQ(p, limitP);
337     EXPECT_EQ(q, limitQ);
338     return result;
339 }
340
341 TEST(IDBLevelDBCodingTest, CompareEncodedStringsWithLength)
342 {
343     const UChar testStringA[] = {0x1000, 0x1000, '\0'};
344     const UChar testStringB[] = {0x1000, 0x1000, 0x1000, '\0'};
345     const UChar testStringC[] = {0x1000, 0x1000, 0x1001, '\0'};
346     const UChar testStringD[] = {0x1001, 0x1000, 0x1000, '\0'};
347     const UChar testStringE[] = {0xd834, 0xdd1e, '\0'};
348     const UChar testStringF[] = {0xfffd, '\0'};
349
350     Vector<String> testCases;
351     testCases.append(String(""));
352     testCases.append(String("a"));
353     testCases.append(String("b"));
354     testCases.append(String("baaa"));
355     testCases.append(String("baab"));
356     testCases.append(String("c"));
357     testCases.append(String(testStringA));
358     testCases.append(String(testStringB));
359     testCases.append(String(testStringC));
360     testCases.append(String(testStringD));
361     testCases.append(String(testStringE));
362     testCases.append(String(testStringF));
363
364     for (size_t i = 0; i < testCases.size() - 1; ++i) {
365         String a = testCases[i];
366         String b = testCases[i + 1];
367
368         EXPECT_LT(codePointCompare(a, b), 0);
369         EXPECT_GT(codePointCompare(b, a), 0);
370         EXPECT_EQ(codePointCompare(a, a), 0);
371         EXPECT_EQ(codePointCompare(b, b), 0);
372
373         Vector<char> encodedA = encodeStringWithLength(a);
374         EXPECT_TRUE(encodedA.size());
375         Vector<char> encodedB = encodeStringWithLength(b);
376         EXPECT_TRUE(encodedA.size());
377
378         const char* p = encodedA.data();
379         const char* limitP = p + encodedA.size();
380         const char* q = encodedB.data();
381         const char* limitQ = q + encodedB.size();
382
383         EXPECT_LT(compareStrings(p, limitP, q, limitQ), 0);
384         EXPECT_GT(compareStrings(q, limitQ, p, limitP), 0);
385         EXPECT_EQ(compareStrings(p, limitP, p, limitP), 0);
386         EXPECT_EQ(compareStrings(q, limitQ, q, limitQ), 0);
387     }
388 }
389
390 TEST(IDBLevelDBCodingTest, EncodeDouble)
391 {
392     EXPECT_EQ(static_cast<size_t>(8), encodeDouble(0).size());
393     EXPECT_EQ(static_cast<size_t>(8), encodeDouble(3.14).size());
394 }
395
396 TEST(IDBLevelDBCodingTest, DecodeDouble)
397 {
398     Vector<char> v;
399     const char* p;
400     double d;
401
402     v = encodeDouble(3.14);
403     p = decodeDouble(v.data(), v.data() + v.size(), &d);
404     EXPECT_EQ(3.14, d);
405     EXPECT_EQ(v.data() + v.size(), p);
406
407     v = encodeDouble(-3.14);
408     p = decodeDouble(v.data(), v.data() + v.size(), &d);
409     EXPECT_EQ(-3.14, d);
410     EXPECT_EQ(v.data() + v.size(), p);
411
412     v = encodeDouble(3.14);
413     p = decodeDouble(v.data(), v.data() + v.size() - 1, &d);
414     EXPECT_EQ(0, p);
415 }
416
417 TEST(IDBLevelDBCodingTest, EncodeDecodeIDBKey)
418 {
419     RefPtr<IDBKey> expectedKey;
420     RefPtr<IDBKey> decodedKey;
421     Vector<char> v;
422     const char* p;
423
424     expectedKey = IDBKey::createNumber(1234);
425     v = encodeIDBKey(*expectedKey);
426     p = decodeIDBKey(v.data(), v.data() + v.size(), decodedKey);
427     EXPECT_TRUE(decodedKey->isEqual(expectedKey.get()));
428     EXPECT_EQ(v.data() + v.size(), p);
429     EXPECT_EQ(0, decodeIDBKey(v.data(), v.data() + v.size() - 1, decodedKey));
430
431     expectedKey = IDBKey::createString("Hello World!");
432     v = encodeIDBKey(*expectedKey);
433     p = decodeIDBKey(v.data(), v.data() + v.size(), decodedKey);
434     EXPECT_TRUE(decodedKey->isEqual(expectedKey.get()));
435     EXPECT_EQ(v.data() + v.size(), p);
436     EXPECT_EQ(0, decodeIDBKey(v.data(), v.data() + v.size() - 1, decodedKey));
437
438     expectedKey = createArrayIDBKey();
439     v = encodeIDBKey(*expectedKey);
440     p = decodeIDBKey(v.data(), v.data() + v.size(), decodedKey);
441     EXPECT_TRUE(decodedKey->isEqual(expectedKey.get()));
442     EXPECT_EQ(v.data() + v.size(), p);
443     EXPECT_EQ(0, decodeIDBKey(v.data(), v.data() + v.size() - 1, decodedKey));
444
445     expectedKey = IDBKey::createDate(7890);
446     v = encodeIDBKey(*expectedKey);
447     p = decodeIDBKey(v.data(), v.data() + v.size(), decodedKey);
448     EXPECT_TRUE(decodedKey->isEqual(expectedKey.get()));
449     EXPECT_EQ(v.data() + v.size(), p);
450     EXPECT_EQ(0, decodeIDBKey(v.data(), v.data() + v.size() - 1, decodedKey));
451
452     IDBKey::KeyArray array;
453     array.append(IDBKey::createNumber(1234));
454     array.append(IDBKey::createString("Hello World!"));
455     array.append(IDBKey::createDate(7890));
456     expectedKey = IDBKey::createArray(array);
457     v = encodeIDBKey(*expectedKey);
458     p = decodeIDBKey(v.data(), v.data() + v.size(), decodedKey);
459     EXPECT_TRUE(decodedKey->isEqual(expectedKey.get()));
460     EXPECT_EQ(v.data() + v.size(), p);
461     EXPECT_EQ(0, decodeIDBKey(v.data(), v.data() + v.size() - 1, decodedKey));
462 }
463
464 TEST(IDBLevelDBCodingTest, EncodeIDBKeyPath)
465 {
466     const unsigned char kIDBKeyPathTypeCodedByte1 = 0;
467     const unsigned char kIDBKeyPathTypeCodedByte2 = 0;
468     {
469         IDBKeyPath keyPath;
470         EXPECT_EQ(keyPath.type(), IDBKeyPath::NullType);
471         Vector<char> v = encodeIDBKeyPath(keyPath);
472         EXPECT_EQ(v.size(), 3U);
473         EXPECT_EQ(v[0], kIDBKeyPathTypeCodedByte1);
474         EXPECT_EQ(v[1], kIDBKeyPathTypeCodedByte2);
475         EXPECT_EQ(v[2], IDBKeyPath::NullType);
476     }
477
478     {
479         Vector<String> testCases;
480         testCases.append("");
481         testCases.append("foo");
482         testCases.append("foo.bar");
483
484         for (size_t i = 0; i < testCases.size(); ++i) {
485             IDBKeyPath keyPath = IDBKeyPath(testCases[i]);
486             Vector<char> v = encodeIDBKeyPath(keyPath);
487             EXPECT_EQ(v.size(), encodeStringWithLength(testCases[i]).size() + 3);
488             const char* p = v.data();
489             const char* limit = v.data() + v.size();
490             EXPECT_EQ(*p++, kIDBKeyPathTypeCodedByte1);
491             EXPECT_EQ(*p++, kIDBKeyPathTypeCodedByte2);
492             EXPECT_EQ(*p++, IDBKeyPath::StringType);
493             String string;
494             p = decodeStringWithLength(p, limit, string);
495             EXPECT_EQ(string, testCases[i]);
496             EXPECT_EQ(p, limit);
497         }
498     }
499
500     {
501         Vector<String> testCase;
502         testCase.append("");
503         testCase.append("foo");
504         testCase.append("foo.bar");
505
506         IDBKeyPath keyPath(testCase);
507         EXPECT_EQ(keyPath.type(), IDBKeyPath::ArrayType);
508         Vector<char> v = encodeIDBKeyPath(keyPath);
509         const char* p = v.data();
510         const char* limit = v.data() + v.size();
511         EXPECT_EQ(*p++, kIDBKeyPathTypeCodedByte1);
512         EXPECT_EQ(*p++, kIDBKeyPathTypeCodedByte2);
513         EXPECT_EQ(*p++, IDBKeyPath::ArrayType);
514         int64_t count;
515         p = decodeVarInt(p, limit, count);
516         EXPECT_EQ(count, static_cast<int64_t>(testCase.size()));
517         for (size_t i = 0; i < static_cast<size_t>(count); ++i) {
518             String string;
519             p = decodeStringWithLength(p, limit, string);
520             EXPECT_EQ(string, testCase[i]);
521         }
522         EXPECT_EQ(p, limit);
523     }
524 }
525
526 TEST(IDBLevelDBCodingTest, DecodeIDBKeyPath)
527 {
528     const unsigned char kIDBKeyPathTypeCodedByte1 = 0;
529     const unsigned char kIDBKeyPathTypeCodedByte2 = 0;
530     {
531         // Legacy encoding of string key paths.
532         Vector<String> testCases;
533         testCases.append("");
534         testCases.append("foo");
535         testCases.append("foo.bar");
536
537         for (size_t i = 0; i < testCases.size(); ++i) {
538             Vector<char> v = encodeString(testCases[i]);
539             IDBKeyPath keyPath = decodeIDBKeyPath(v.data(), v.data() + v.size());
540             EXPECT_EQ(keyPath.type(), IDBKeyPath::StringType);
541             EXPECT_EQ(testCases[i], keyPath.string());
542         }
543     }
544     {
545         Vector<char> v;
546         v.append(kIDBKeyPathTypeCodedByte1);
547         v.append(kIDBKeyPathTypeCodedByte2);
548         v.append(IDBKeyPath::NullType);
549         IDBKeyPath keyPath = decodeIDBKeyPath(v.data(), v.data() + v.size());
550         EXPECT_EQ(keyPath.type(), IDBKeyPath::NullType);
551         EXPECT_TRUE(keyPath.isNull());
552     }
553     {
554         Vector<String> testCases;
555         testCases.append("");
556         testCases.append("foo");
557         testCases.append("foo.bar");
558
559         for (size_t i = 0; i < testCases.size(); ++i) {
560             Vector<char> v;
561             v.append(kIDBKeyPathTypeCodedByte1);
562             v.append(kIDBKeyPathTypeCodedByte2);
563             v.append(IDBKeyPath::StringType);
564             v.append(encodeStringWithLength(testCases[i]));
565             IDBKeyPath keyPath = decodeIDBKeyPath(v.data(), v.data() + v.size());
566             EXPECT_EQ(keyPath.type(), IDBKeyPath::StringType);
567             EXPECT_EQ(testCases[i], keyPath.string());
568         }
569     }
570     {
571         Vector<String> testCase;
572         testCase.append("");
573         testCase.append("foo");
574         testCase.append("foo.bar");
575
576         Vector<char> v;
577         v.append(kIDBKeyPathTypeCodedByte1);
578         v.append(kIDBKeyPathTypeCodedByte2);
579         v.append(IDBKeyPath::ArrayType);
580         v.append(encodeVarInt(testCase.size()));
581         for (size_t i = 0; i < testCase.size(); ++i)
582             v.append(encodeStringWithLength(testCase[i]));
583         IDBKeyPath keyPath = decodeIDBKeyPath(v.data(), v.data() + v.size());
584         EXPECT_EQ(keyPath.type(), IDBKeyPath::ArrayType);
585         EXPECT_EQ(keyPath.array().size(), testCase.size());
586         for (size_t i = 0; i < testCase.size(); ++i)
587             EXPECT_EQ(keyPath.array()[i], testCase[i]);
588     }
589 }
590
591 TEST(IDBLevelDBCodingTest, ExtractAndCompareIDBKeys)
592 {
593     Vector<RefPtr<IDBKey> > keys;
594
595     keys.append(IDBKey::createNumber(-10));
596     keys.append(IDBKey::createNumber(0));
597     keys.append(IDBKey::createNumber(3.14));
598
599     keys.append(IDBKey::createDate(0));
600     keys.append(IDBKey::createDate(100));
601     keys.append(IDBKey::createDate(100000));
602
603     keys.append(IDBKey::createString(""));
604     keys.append(IDBKey::createString("a"));
605     keys.append(IDBKey::createString("b"));
606     keys.append(IDBKey::createString("baaa"));
607     keys.append(IDBKey::createString("baab"));
608     keys.append(IDBKey::createString("c"));
609
610     keys.append(createArrayIDBKey());
611     keys.append(createArrayIDBKey(IDBKey::createNumber(0)));
612     keys.append(createArrayIDBKey(IDBKey::createNumber(0), IDBKey::createNumber(3.14)));
613     keys.append(createArrayIDBKey(IDBKey::createDate(0)));
614     keys.append(createArrayIDBKey(IDBKey::createDate(0), IDBKey::createDate(0)));
615     keys.append(createArrayIDBKey(IDBKey::createString("")));
616     keys.append(createArrayIDBKey(IDBKey::createString(""), IDBKey::createString("a")));
617     keys.append(createArrayIDBKey(createArrayIDBKey()));
618     keys.append(createArrayIDBKey(createArrayIDBKey(), createArrayIDBKey()));
619     keys.append(createArrayIDBKey(createArrayIDBKey(createArrayIDBKey())));
620     keys.append(createArrayIDBKey(createArrayIDBKey(createArrayIDBKey(createArrayIDBKey()))));
621
622     for (size_t i = 0; i < keys.size() - 1; ++i) {
623         RefPtr<IDBKey> keyA = keys[i];
624         RefPtr<IDBKey> keyB = keys[i + 1];
625
626         EXPECT_TRUE(keyA->isLessThan(keyB.get()));
627
628         Vector<char> encodedA = encodeIDBKey(*keyA);
629         EXPECT_TRUE(encodedA.size());
630         Vector<char> encodedB = encodeIDBKey(*keyB);
631         EXPECT_TRUE(encodedB.size());
632
633         Vector<char> extractedA;
634         Vector<char> extractedB;
635
636         const char* p = extractEncodedIDBKey(encodedA.data(), encodedA.data() + encodedA.size(), &extractedA);
637         EXPECT_EQ(encodedA.data() + encodedA.size(), p);
638         EXPECT_EQ(encodedA, extractedA);
639
640         const char* q = extractEncodedIDBKey(encodedB.data(), encodedB.data() + encodedB.size(), &extractedB);
641         EXPECT_EQ(encodedB.data() + encodedB.size(), q);
642         EXPECT_EQ(encodedB, extractedB);
643
644         EXPECT_LT(compareKeys(extractedA, extractedB), 0);
645         EXPECT_GT(compareKeys(extractedB, extractedA), 0);
646         EXPECT_EQ(compareKeys(extractedA, extractedA), 0);
647         EXPECT_EQ(compareKeys(extractedB, extractedB), 0);
648
649         EXPECT_EQ(0, extractEncodedIDBKey(encodedA.data(), encodedA.data() + encodedA.size() - 1, &extractedA));
650     }
651 }
652
653 TEST(IDBLevelDBCodingTest, ComparisonTest)
654 {
655     Vector<Vector<char> > keys;
656     keys.append(SchemaVersionKey::encode());
657     keys.append(MaxDatabaseIdKey::encode());
658     keys.append(DatabaseFreeListKey::encode(0));
659     keys.append(DatabaseFreeListKey::encodeMaxKey());
660     keys.append(DatabaseNameKey::encode("", ""));
661     keys.append(DatabaseNameKey::encode("", "a"));
662     keys.append(DatabaseNameKey::encode("a", "a"));
663     keys.append(DatabaseMetaDataKey::encode(1, DatabaseMetaDataKey::OriginName));
664     keys.append(DatabaseMetaDataKey::encode(1, DatabaseMetaDataKey::DatabaseName));
665     keys.append(DatabaseMetaDataKey::encode(1, DatabaseMetaDataKey::UserVersion));
666     keys.append(DatabaseMetaDataKey::encode(1, DatabaseMetaDataKey::MaxObjectStoreId));
667     keys.append(DatabaseMetaDataKey::encode(1, DatabaseMetaDataKey::UserIntVersion));
668     keys.append(ObjectStoreMetaDataKey::encode(1, 1, ObjectStoreMetaDataKey::Name));
669     keys.append(ObjectStoreMetaDataKey::encode(1, 1, ObjectStoreMetaDataKey::KeyPath));
670     keys.append(ObjectStoreMetaDataKey::encode(1, 1, ObjectStoreMetaDataKey::AutoIncrement));
671     keys.append(ObjectStoreMetaDataKey::encode(1, 1, ObjectStoreMetaDataKey::Evictable));
672     keys.append(ObjectStoreMetaDataKey::encode(1, 1, ObjectStoreMetaDataKey::LastVersion));
673     keys.append(ObjectStoreMetaDataKey::encode(1, 1, ObjectStoreMetaDataKey::MaxIndexId));
674     keys.append(ObjectStoreMetaDataKey::encode(1, 1, ObjectStoreMetaDataKey::HasKeyPath));
675     keys.append(ObjectStoreMetaDataKey::encode(1, 1, ObjectStoreMetaDataKey::KeyGeneratorCurrentNumber));
676     keys.append(ObjectStoreMetaDataKey::encodeMaxKey(1, 1));
677     keys.append(ObjectStoreMetaDataKey::encodeMaxKey(1, 2));
678     keys.append(ObjectStoreMetaDataKey::encodeMaxKey(1));
679     keys.append(IndexMetaDataKey::encode(1, 1, 30, IndexMetaDataKey::Name));
680     keys.append(IndexMetaDataKey::encode(1, 1, 30, IndexMetaDataKey::Unique));
681     keys.append(IndexMetaDataKey::encode(1, 1, 30, IndexMetaDataKey::KeyPath));
682     keys.append(IndexMetaDataKey::encode(1, 1, 30, IndexMetaDataKey::MultiEntry));
683     keys.append(IndexMetaDataKey::encode(1, 1, 31, 0));
684     keys.append(IndexMetaDataKey::encode(1, 1, 31, 1));
685     keys.append(IndexMetaDataKey::encodeMaxKey(1, 1, 31));
686     keys.append(IndexMetaDataKey::encodeMaxKey(1, 1, 32));
687     keys.append(IndexMetaDataKey::encodeMaxKey(1, 1));
688     keys.append(IndexMetaDataKey::encodeMaxKey(1, 2));
689     keys.append(ObjectStoreFreeListKey::encode(1, 1));
690     keys.append(ObjectStoreFreeListKey::encodeMaxKey(1));
691     keys.append(IndexFreeListKey::encode(1, 1, MinimumIndexId));
692     keys.append(IndexFreeListKey::encodeMaxKey(1, 1));
693     keys.append(IndexFreeListKey::encode(1, 2, MinimumIndexId));
694     keys.append(IndexFreeListKey::encodeMaxKey(1, 2));
695     keys.append(ObjectStoreNamesKey::encode(1, ""));
696     keys.append(ObjectStoreNamesKey::encode(1, "a"));
697     keys.append(IndexNamesKey::encode(1, 1, ""));
698     keys.append(IndexNamesKey::encode(1, 1, "a"));
699     keys.append(IndexNamesKey::encode(1, 2, "a"));
700     keys.append(ObjectStoreDataKey::encode(1, 1, minIDBKey()));
701     keys.append(ObjectStoreDataKey::encode(1, 1, maxIDBKey()));
702     keys.append(ExistsEntryKey::encode(1, 1, minIDBKey()));
703     keys.append(ExistsEntryKey::encode(1, 1, maxIDBKey()));
704     keys.append(IndexDataKey::encode(1, 1, 30, minIDBKey(), minIDBKey(), 0));
705     keys.append(IndexDataKey::encode(1, 1, 30, minIDBKey(), minIDBKey(), 1));
706     keys.append(IndexDataKey::encode(1, 1, 30, minIDBKey(), maxIDBKey(), 0));
707     keys.append(IndexDataKey::encode(1, 1, 30, minIDBKey(), maxIDBKey(), 1));
708     keys.append(IndexDataKey::encode(1, 1, 30, maxIDBKey(), minIDBKey(), 0));
709     keys.append(IndexDataKey::encode(1, 1, 30, maxIDBKey(), minIDBKey(), 1));
710     keys.append(IndexDataKey::encode(1, 1, 30, maxIDBKey(), maxIDBKey(), 0));
711     keys.append(IndexDataKey::encode(1, 1, 30, maxIDBKey(), maxIDBKey(), 1));
712     keys.append(IndexDataKey::encode(1, 1, 31, minIDBKey(), minIDBKey(), 0));
713     keys.append(IndexDataKey::encode(1, 2, 30, minIDBKey(), minIDBKey(), 0));
714     keys.append(IndexDataKey::encodeMaxKey(1, 2, INT32_MAX));
715
716     for (size_t i = 0; i < keys.size(); ++i) {
717         const LevelDBSlice keyA(keys[i]);
718         EXPECT_EQ(compare(keyA, keyA), 0);
719
720         for (size_t j = i + 1; j < keys.size(); ++j) {
721             const LevelDBSlice keyB(keys[j]);
722             EXPECT_LT(compare(keyA, keyB), 0);
723             EXPECT_GT(compare(keyB, keyA), 0);
724         }
725     }
726 }
727
728 TEST(IDBLevelDBCodingTest, EncodeVarIntVSEncodeByteTest)
729 {
730     Vector<unsigned char> testCases;
731     testCases.append(0);
732     testCases.append(1);
733     testCases.append(127);
734
735     for (size_t i = 0; i < testCases.size(); ++i) {
736         unsigned char n = testCases[i];
737
738         Vector<char> vA = encodeByte(n);
739         Vector<char> vB = encodeVarInt(static_cast<int64_t>(n));
740
741         EXPECT_EQ(vA.size(), vB.size());
742         EXPECT_EQ(*(vA.data()), *(vB.data()));
743     }
744 }
745
746 } // namespace
747
748 #endif // USE(LEVELDB)
749 #endif // ENABLE(INDEXED_DATABASE)