IndexedDB: Indexes should be secondarily sorted on primary key
[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 "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 static PassRefPtr<IDBKey> createArrayIDBKey()
43 {
44     return IDBKey::createArray(IDBKey::KeyArray());
45 }
46
47 static PassRefPtr<IDBKey> createArrayIDBKey(PassRefPtr<IDBKey> prpKey1)
48 {
49     RefPtr<IDBKey> key1 = prpKey1;
50
51     IDBKey::KeyArray array;
52     array.append(key1);
53     return IDBKey::createArray(array);
54 }
55
56 static PassRefPtr<IDBKey> createArrayIDBKey(PassRefPtr<IDBKey> prpKey1, PassRefPtr<IDBKey> prpKey2)
57 {
58     RefPtr<IDBKey> key1 = prpKey1;
59     RefPtr<IDBKey> key2 = prpKey2;
60
61     IDBKey::KeyArray array;
62     array.append(key1);
63     array.append(key2);
64     return IDBKey::createArray(array);
65 }
66
67 TEST(IDBLevelDBCodingTest, EncodeByte)
68 {
69     Vector<char> expected;
70     expected.append(0);
71     unsigned char c;
72
73     c = 0;
74     expected[0] = c;
75     EXPECT_EQ(expected, encodeByte(c));
76
77     c = 1;
78     expected[0] = c;
79     EXPECT_EQ(expected, encodeByte(c));
80
81     c = 255;
82     expected[0] = c;
83     EXPECT_EQ(expected, encodeByte(c));
84 }
85
86 TEST(IDBLevelDBCodingTest, MaxIDBKey)
87 {
88     Vector<char> maxKey = maxIDBKey();
89
90     Vector<char> minKey = minIDBKey();
91     Vector<char> arrayKey = encodeIDBKey(*IDBKey::createArray(IDBKey::KeyArray()));
92     Vector<char> stringKey = encodeIDBKey(*IDBKey::createString("Hello world"));
93     Vector<char> numberKey = encodeIDBKey(*IDBKey::createNumber(3.14));
94     Vector<char> dateKey = encodeIDBKey(*IDBKey::createDate(1000000));
95
96     EXPECT_GT(compareEncodedIDBKeys(maxKey, minKey), 0);
97     EXPECT_GT(compareEncodedIDBKeys(maxKey, arrayKey), 0);
98     EXPECT_GT(compareEncodedIDBKeys(maxKey, stringKey), 0);
99     EXPECT_GT(compareEncodedIDBKeys(maxKey, numberKey), 0);
100     EXPECT_GT(compareEncodedIDBKeys(maxKey, dateKey), 0);
101 }
102
103 TEST(IDBLevelDBCodingTest, MinIDBKey)
104 {
105     Vector<char> minKey = minIDBKey();
106
107     Vector<char> maxKey = maxIDBKey();
108     Vector<char> arrayKey = encodeIDBKey(*IDBKey::createArray(IDBKey::KeyArray()));
109     Vector<char> stringKey = encodeIDBKey(*IDBKey::createString("Hello world"));
110     Vector<char> numberKey = encodeIDBKey(*IDBKey::createNumber(3.14));
111     Vector<char> dateKey = encodeIDBKey(*IDBKey::createDate(1000000));
112
113     EXPECT_LT(compareEncodedIDBKeys(minKey, maxKey), 0);
114     EXPECT_LT(compareEncodedIDBKeys(minKey, arrayKey), 0);
115     EXPECT_LT(compareEncodedIDBKeys(minKey, stringKey), 0);
116     EXPECT_LT(compareEncodedIDBKeys(minKey, numberKey), 0);
117     EXPECT_LT(compareEncodedIDBKeys(minKey, dateKey), 0);
118 }
119
120 TEST(IDBLevelDBCodingTest, EncodeInt)
121 {
122     EXPECT_EQ(static_cast<size_t>(1), encodeInt(0).size());
123     EXPECT_EQ(static_cast<size_t>(1), encodeInt(1).size());
124     EXPECT_EQ(static_cast<size_t>(1), encodeInt(255).size());
125     EXPECT_EQ(static_cast<size_t>(2), encodeInt(256).size());
126     EXPECT_EQ(static_cast<size_t>(4), encodeInt(0xffffffff).size());
127 }
128
129 TEST(IDBLevelDBCodingTest, DecodeInt)
130 {
131     Vector<int64_t> testCases;
132     testCases.append(0);
133     testCases.append(1);
134     testCases.append(255);
135     testCases.append(256);
136     testCases.append(65535);
137     testCases.append(655536);
138     testCases.append(7711192431755665792ll);
139     testCases.append(0x7fffffffffffffffll);
140
141     for (size_t i = 0; i < testCases.size(); ++i) {
142         int64_t n = testCases[i];
143         Vector<char> v = encodeInt(n);
144         EXPECT_EQ(n, decodeInt(v.data(), v.data() + v.size()));
145     }
146 }
147
148 TEST(IDBLevelDBCodingTest, EncodeVarInt)
149 {
150     EXPECT_EQ(static_cast<size_t>(1), encodeVarInt(0).size());
151     EXPECT_EQ(static_cast<size_t>(1), encodeVarInt(1).size());
152     EXPECT_EQ(static_cast<size_t>(2), encodeVarInt(255).size());
153     EXPECT_EQ(static_cast<size_t>(2), encodeVarInt(256).size());
154     EXPECT_EQ(static_cast<size_t>(5), encodeVarInt(0xffffffff).size());
155 }
156
157 TEST(IDBLevelDBCodingTest, DecodeVarInt)
158 {
159     Vector<int64_t> testCases;
160     testCases.append(0);
161     testCases.append(1);
162     testCases.append(255);
163     testCases.append(256);
164     testCases.append(65535);
165     testCases.append(655536);
166     testCases.append(7711192431755665792ll);
167     testCases.append(0x7fffffffffffffffll);
168
169     for (size_t i = 0; i < testCases.size(); ++i) {
170         int64_t n = testCases[i];
171         Vector<char> v = encodeVarInt(n);
172
173         int64_t res;
174         const char* p = decodeVarInt(v.data(), v.data() + v.size(), res);
175         EXPECT_EQ(n, res);
176         EXPECT_EQ(v.data() + v.size(), p);
177
178         p = decodeVarInt(v.data(), v.data() + v.size() - 1, res);
179         EXPECT_EQ(0, p);
180         p = decodeVarInt(v.data(), v.data(), res);
181         EXPECT_EQ(0, p);
182     }
183 }
184
185 TEST(IDBLevelDBCodingTest, EncodeString)
186 {
187     const UChar testStringA[] = {'f', 'o', 'o', '\0'};
188     const UChar testStringB[] = {0xdead, 0xbeef, '\0'};
189
190     EXPECT_EQ(static_cast<size_t>(0), encodeString(String("")).size());
191     EXPECT_EQ(static_cast<size_t>(2), encodeString(String("a")).size());
192     EXPECT_EQ(static_cast<size_t>(6), encodeString(String("foo")).size());
193     EXPECT_EQ(static_cast<size_t>(6), encodeString(String(testStringA)).size());
194     EXPECT_EQ(static_cast<size_t>(4), encodeString(String(testStringB)).size());
195 }
196
197 TEST(IDBLevelDBCodingTest, DecodeString)
198 {
199     const UChar testStringA[] = {'f', 'o', 'o', '\0'};
200     const UChar testStringB[] = {0xdead, 0xbeef, '\0'};
201     Vector<char> v;
202
203     v = encodeString(String(""));
204     EXPECT_EQ(String(""), decodeString(v.data(), v.data() + v.size()));
205
206     v = encodeString(String("a"));
207     EXPECT_EQ(String("a"), decodeString(v.data(), v.data() + v.size()));
208
209     v = encodeString(String("foo"));
210     EXPECT_EQ(String("foo"), decodeString(v.data(), v.data() + v.size()));
211
212     v = encodeString(String(testStringA));
213     EXPECT_EQ(String(testStringA), decodeString(v.data(), v.data() + v.size()));
214
215     v = encodeString(String(testStringB));
216     EXPECT_EQ(String(testStringB), decodeString(v.data(), v.data() + v.size()));
217 }
218
219 TEST(IDBLevelDBCodingTest, EncodeStringWithLength)
220 {
221     const UChar testStringA[] = {'f', 'o', 'o', '\0'};
222     const UChar testStringB[] = {0xdead, 0xbeef, '\0'};
223
224     EXPECT_EQ(static_cast<size_t>(1), encodeStringWithLength(String("")).size());
225     EXPECT_EQ(static_cast<size_t>(3), encodeStringWithLength(String("a")).size());
226     EXPECT_EQ(static_cast<size_t>(7), encodeStringWithLength(String(testStringA)).size());
227     EXPECT_EQ(static_cast<size_t>(5), encodeStringWithLength(String(testStringB)).size());
228 }
229
230 TEST(IDBLevelDBCodingTest, DecodeStringWithLength)
231 {
232     const UChar testStringA[] = {'f', 'o', 'o', '\0'};
233     const UChar testStringB[] = {0xdead, 0xbeef, '\0'};
234
235     const int kLongStringLen = 1234;
236     UChar longString[kLongStringLen + 1];
237     for (int i = 0; i < kLongStringLen; ++i)
238         longString[i] = i;
239     longString[kLongStringLen] = 0;
240
241     Vector<String> testCases;
242     testCases.append(String(""));
243     testCases.append(String("a"));
244     testCases.append(String("foo"));
245     testCases.append(String(testStringA));
246     testCases.append(String(testStringB));
247     testCases.append(String(longString));
248
249     for (size_t i = 0; i < testCases.size(); ++i) {
250         String s = testCases[i];
251         Vector<char> v = encodeStringWithLength(s);
252         String res;
253         const char* p = decodeStringWithLength(v.data(), v.data() + v.size(), res);
254         EXPECT_EQ(s, res);
255         EXPECT_EQ(v.data() + v.size(), p);
256
257         EXPECT_EQ(0, decodeStringWithLength(v.data(), v.data() + v.size() - 1, res));
258         EXPECT_EQ(0, decodeStringWithLength(v.data(), v.data(), res));
259     }
260 }
261
262 static int compareStrings(const char* p, const char* limitP, const char* q, const char* limitQ)
263 {
264     int result = compareEncodedStringsWithLength(p, limitP, q, limitQ);
265     EXPECT_EQ(p, limitP);
266     EXPECT_EQ(q, limitQ);
267     return result;
268 }
269
270 TEST(IDBLevelDBCodingTest, CompareEncodedStringsWithLength)
271 {
272     const UChar testStringA[] = {0x1000, 0x1000, '\0'};
273     const UChar testStringB[] = {0x1000, 0x1000, 0x1000, '\0'};
274     const UChar testStringC[] = {0x1000, 0x1000, 0x1001, '\0'};
275     const UChar testStringD[] = {0x1001, 0x1000, 0x1000, '\0'};
276     const UChar testStringE[] = {0xd834, 0xdd1e, '\0'};
277     const UChar testStringF[] = {0xfffd, '\0'};
278
279     Vector<String> testCases;
280     testCases.append(String(""));
281     testCases.append(String("a"));
282     testCases.append(String("b"));
283     testCases.append(String("baaa"));
284     testCases.append(String("baab"));
285     testCases.append(String("c"));
286     testCases.append(String(testStringA));
287     testCases.append(String(testStringB));
288     testCases.append(String(testStringC));
289     testCases.append(String(testStringD));
290     testCases.append(String(testStringE));
291     testCases.append(String(testStringF));
292
293     for (size_t i = 0; i < testCases.size() - 1; ++i) {
294         String a = testCases[i];
295         String b = testCases[i + 1];
296
297         EXPECT_LT(codePointCompare(a, b), 0);
298         EXPECT_GT(codePointCompare(b, a), 0);
299         EXPECT_EQ(codePointCompare(a, a), 0);
300         EXPECT_EQ(codePointCompare(b, b), 0);
301
302         Vector<char> encodedA = encodeStringWithLength(a);
303         EXPECT_TRUE(encodedA.size());
304         Vector<char> encodedB = encodeStringWithLength(b);
305         EXPECT_TRUE(encodedA.size());
306
307         const char* p = encodedA.data();
308         const char* limitP = p + encodedA.size();
309         const char* q = encodedB.data();
310         const char* limitQ = q + encodedB.size();
311
312         EXPECT_LT(compareStrings(p, limitP, q, limitQ), 0);
313         EXPECT_GT(compareStrings(q, limitQ, p, limitP), 0);
314         EXPECT_EQ(compareStrings(p, limitP, p, limitP), 0);
315         EXPECT_EQ(compareStrings(q, limitQ, q, limitQ), 0);
316     }
317 }
318
319 TEST(IDBLevelDBCodingTest, EncodeDouble)
320 {
321     EXPECT_EQ(static_cast<size_t>(8), encodeDouble(0).size());
322     EXPECT_EQ(static_cast<size_t>(8), encodeDouble(3.14).size());
323 }
324
325 TEST(IDBLevelDBCodingTest, DecodeDouble)
326 {
327     Vector<char> v;
328     const char* p;
329     double d;
330
331     v = encodeDouble(3.14);
332     p = decodeDouble(v.data(), v.data() + v.size(), &d);
333     EXPECT_EQ(3.14, d);
334     EXPECT_EQ(v.data() + v.size(), p);
335
336     v = encodeDouble(-3.14);
337     p = decodeDouble(v.data(), v.data() + v.size(), &d);
338     EXPECT_EQ(-3.14, d);
339     EXPECT_EQ(v.data() + v.size(), p);
340
341     v = encodeDouble(3.14);
342     p = decodeDouble(v.data(), v.data() + v.size() - 1, &d);
343     EXPECT_EQ(0, p);
344 }
345
346 TEST(IDBLevelDBCodingTest, EncodeDecodeIDBKey)
347 {
348     RefPtr<IDBKey> expectedKey;
349     RefPtr<IDBKey> decodedKey;
350     Vector<char> v;
351     const char* p;
352
353     expectedKey = IDBKey::createNumber(1234);
354     v = encodeIDBKey(*expectedKey);
355     p = decodeIDBKey(v.data(), v.data() + v.size(), decodedKey);
356     EXPECT_TRUE(decodedKey->isEqual(expectedKey.get()));
357     EXPECT_EQ(v.data() + v.size(), p);
358     EXPECT_EQ(0, decodeIDBKey(v.data(), v.data() + v.size() - 1, decodedKey));
359
360     expectedKey = IDBKey::createString("Hello World!");
361     v = encodeIDBKey(*expectedKey);
362     p = decodeIDBKey(v.data(), v.data() + v.size(), decodedKey);
363     EXPECT_TRUE(decodedKey->isEqual(expectedKey.get()));
364     EXPECT_EQ(v.data() + v.size(), p);
365     EXPECT_EQ(0, decodeIDBKey(v.data(), v.data() + v.size() - 1, decodedKey));
366
367     expectedKey = createArrayIDBKey();
368     v = encodeIDBKey(*expectedKey);
369     p = decodeIDBKey(v.data(), v.data() + v.size(), decodedKey);
370     EXPECT_TRUE(decodedKey->isEqual(expectedKey.get()));
371     EXPECT_EQ(v.data() + v.size(), p);
372     EXPECT_EQ(0, decodeIDBKey(v.data(), v.data() + v.size() - 1, decodedKey));
373
374     expectedKey = IDBKey::createDate(7890);
375     v = encodeIDBKey(*expectedKey);
376     p = decodeIDBKey(v.data(), v.data() + v.size(), decodedKey);
377     EXPECT_TRUE(decodedKey->isEqual(expectedKey.get()));
378     EXPECT_EQ(v.data() + v.size(), p);
379     EXPECT_EQ(0, decodeIDBKey(v.data(), v.data() + v.size() - 1, decodedKey));
380
381     IDBKey::KeyArray array;
382     array.append(IDBKey::createNumber(1234));
383     array.append(IDBKey::createString("Hello World!"));
384     array.append(IDBKey::createDate(7890));
385     expectedKey = IDBKey::createArray(array);
386     v = encodeIDBKey(*expectedKey);
387     p = decodeIDBKey(v.data(), v.data() + v.size(), decodedKey);
388     EXPECT_TRUE(decodedKey->isEqual(expectedKey.get()));
389     EXPECT_EQ(v.data() + v.size(), p);
390     EXPECT_EQ(0, decodeIDBKey(v.data(), v.data() + v.size() - 1, decodedKey));
391 }
392
393 TEST(IDBLevelDBCodingTest, ExtractAndCompareIDBKeys)
394 {
395     Vector<RefPtr<IDBKey> > keys;
396
397     keys.append(IDBKey::createNumber(-10));
398     keys.append(IDBKey::createNumber(0));
399     keys.append(IDBKey::createNumber(3.14));
400
401     keys.append(IDBKey::createDate(0));
402     keys.append(IDBKey::createDate(100));
403     keys.append(IDBKey::createDate(100000));
404
405     keys.append(IDBKey::createString(""));
406     keys.append(IDBKey::createString("a"));
407     keys.append(IDBKey::createString("b"));
408     keys.append(IDBKey::createString("baaa"));
409     keys.append(IDBKey::createString("baab"));
410     keys.append(IDBKey::createString("c"));
411
412     keys.append(createArrayIDBKey());
413     keys.append(createArrayIDBKey(IDBKey::createNumber(0)));
414     keys.append(createArrayIDBKey(IDBKey::createNumber(0), IDBKey::createNumber(3.14)));
415     keys.append(createArrayIDBKey(IDBKey::createDate(0)));
416     keys.append(createArrayIDBKey(IDBKey::createDate(0), IDBKey::createDate(0)));
417     keys.append(createArrayIDBKey(IDBKey::createString("")));
418     keys.append(createArrayIDBKey(IDBKey::createString(""), IDBKey::createString("a")));
419     keys.append(createArrayIDBKey(createArrayIDBKey()));
420     keys.append(createArrayIDBKey(createArrayIDBKey(), createArrayIDBKey()));
421     keys.append(createArrayIDBKey(createArrayIDBKey(createArrayIDBKey())));
422     keys.append(createArrayIDBKey(createArrayIDBKey(createArrayIDBKey(createArrayIDBKey()))));
423
424     for (size_t i = 0; i < keys.size() - 1; ++i) {
425         RefPtr<IDBKey> keyA = keys[i];
426         RefPtr<IDBKey> keyB = keys[i + 1];
427
428         EXPECT_TRUE(keyA->isLessThan(keyB.get()));
429
430         Vector<char> encodedA = encodeIDBKey(*keyA);
431         EXPECT_TRUE(encodedA.size());
432         Vector<char> encodedB = encodeIDBKey(*keyB);
433         EXPECT_TRUE(encodedB.size());
434
435         Vector<char> extractedA;
436         Vector<char> extractedB;
437
438         const char* p = extractEncodedIDBKey(encodedA.data(), encodedA.data() + encodedA.size(), &extractedA);
439         EXPECT_EQ(encodedA.data() + encodedA.size(), p);
440         EXPECT_EQ(encodedA, extractedA);
441
442         const char* q = extractEncodedIDBKey(encodedB.data(), encodedB.data() + encodedB.size(), &extractedB);
443         EXPECT_EQ(encodedB.data() + encodedB.size(), q);
444         EXPECT_EQ(encodedB, extractedB);
445
446         EXPECT_LT(compareEncodedIDBKeys(extractedA, extractedB), 0);
447         EXPECT_GT(compareEncodedIDBKeys(extractedB, extractedA), 0);
448         EXPECT_EQ(compareEncodedIDBKeys(extractedA, extractedA), 0);
449         EXPECT_EQ(compareEncodedIDBKeys(extractedB, extractedB), 0);
450
451         EXPECT_EQ(0, extractEncodedIDBKey(encodedA.data(), encodedA.data() + encodedA.size() - 1, &extractedA));
452     }
453 }
454
455 TEST(IDBLevelDBCodingTest, ComparisonTest)
456 {
457     Vector<Vector<char> > keys;
458     keys.append(SchemaVersionKey::encode());
459     keys.append(MaxDatabaseIdKey::encode());
460     keys.append(DatabaseFreeListKey::encode(0));
461     keys.append(DatabaseFreeListKey::encodeMaxKey());
462     keys.append(DatabaseNameKey::encode("", ""));
463     keys.append(DatabaseNameKey::encode("", "a"));
464     keys.append(DatabaseNameKey::encode("a", "a"));
465     keys.append(DatabaseMetaDataKey::encode(1, DatabaseMetaDataKey::kOriginName));
466     keys.append(ObjectStoreMetaDataKey::encode(1, 1, 0));
467     keys.append(ObjectStoreMetaDataKey::encodeMaxKey(1));
468     keys.append(IndexMetaDataKey::encode(1, 1, 30, 0));
469     keys.append(IndexMetaDataKey::encode(1, 1, 31, 0));
470     keys.append(IndexMetaDataKey::encode(1, 1, 31, 1));
471     keys.append(ObjectStoreFreeListKey::encode(1, 1));
472     keys.append(ObjectStoreFreeListKey::encodeMaxKey(1));
473     keys.append(IndexFreeListKey::encode(1, 1, kMinimumIndexId));
474     keys.append(IndexFreeListKey::encodeMaxKey(1, 1));
475     keys.append(IndexFreeListKey::encode(1, 2, kMinimumIndexId));
476     keys.append(IndexFreeListKey::encodeMaxKey(1, 2));
477     keys.append(ObjectStoreNamesKey::encode(1, ""));
478     keys.append(ObjectStoreNamesKey::encode(1, "a"));
479     keys.append(IndexNamesKey::encode(1, 1, ""));
480     keys.append(IndexNamesKey::encode(1, 1, "a"));
481     keys.append(IndexNamesKey::encode(1, 2, "a"));
482     keys.append(ObjectStoreDataKey::encode(1, 1, minIDBKey()));
483     keys.append(ObjectStoreDataKey::encode(1, 1, maxIDBKey()));
484     keys.append(ExistsEntryKey::encode(1, 1, minIDBKey()));
485     keys.append(ExistsEntryKey::encode(1, 1, maxIDBKey()));
486     keys.append(IndexDataKey::encode(1, 1, 30, minIDBKey(), minIDBKey(), 0));
487     keys.append(IndexDataKey::encode(1, 1, 30, minIDBKey(), minIDBKey(), 1));
488     keys.append(IndexDataKey::encode(1, 1, 30, minIDBKey(), maxIDBKey(), 0));
489     keys.append(IndexDataKey::encode(1, 1, 30, minIDBKey(), maxIDBKey(), 1));
490     keys.append(IndexDataKey::encode(1, 1, 30, maxIDBKey(), minIDBKey(), 0));
491     keys.append(IndexDataKey::encode(1, 1, 30, maxIDBKey(), minIDBKey(), 1));
492     keys.append(IndexDataKey::encode(1, 1, 30, maxIDBKey(), maxIDBKey(), 0));
493     keys.append(IndexDataKey::encode(1, 1, 30, maxIDBKey(), maxIDBKey(), 1));
494     keys.append(IndexDataKey::encode(1, 1, 31, minIDBKey(), minIDBKey(), 0));
495     keys.append(IndexDataKey::encode(1, 2, 30, minIDBKey(), minIDBKey(), 0));
496     keys.append(IndexDataKey::encodeMaxKey(1, 2, INT32_MAX));
497
498     for (size_t i = 0; i < keys.size(); ++i) {
499         const LevelDBSlice keyA(keys[i]);
500         EXPECT_EQ(compare(keyA, keyA), 0);
501
502         for (size_t j = i + 1; j < keys.size(); ++j) {
503             const LevelDBSlice keyB(keys[j]);
504             EXPECT_LT(compare(keyA, keyB), 0);
505             EXPECT_GT(compare(keyB, keyA), 0);
506         }
507     }
508 }
509
510 } // namespace
511
512 #endif // USE(LEVELDB)
513 #endif // ENABLE(INDEXED_DATABASE)