Merge 143347

Source/WebKit/chromium/tests/IDBLevelDBCodingTest.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 98 matching lines @@
         expected.append(1);
         EXPECT_EQ(expected, encodeBool(true));
     }
     {
         Vector<char> expected;
         expected.append(0);
         EXPECT_EQ(expected, encodeBool(false));
     }
 }
 
+static int compareKeys(const Vector<char>& a, const Vector<char>& b)
+{
+    bool ok;
+    int result = compareEncodedIDBKeys(a, b, ok);
+    EXPECT_TRUE(ok);
+    return result;
+}
+
 TEST(IDBLevelDBCodingTest, MaxIDBKey)
 {
     Vector<char> maxKey = maxIDBKey();
 
     Vector<char> minKey = minIDBKey();
     Vector<char> arrayKey = encodeIDBKey(*IDBKey::createArray(IDBKey::KeyArray()));
     Vector<char> stringKey = encodeIDBKey(*IDBKey::createString("Hello world"));
     Vector<char> numberKey = encodeIDBKey(*IDBKey::createNumber(3.14));
     Vector<char> dateKey = encodeIDBKey(*IDBKey::createDate(1000000));
 
-    EXPECT_GT(compareEncodedIDBKeys(maxKey, minKey), 0);
-    EXPECT_GT(compareEncodedIDBKeys(maxKey, arrayKey), 0);
-    EXPECT_GT(compareEncodedIDBKeys(maxKey, stringKey), 0);
-    EXPECT_GT(compareEncodedIDBKeys(maxKey, numberKey), 0);
-    EXPECT_GT(compareEncodedIDBKeys(maxKey, dateKey), 0);
+    EXPECT_GT(compareKeys(maxKey, minKey), 0);
+    EXPECT_GT(compareKeys(maxKey, arrayKey), 0);
+    EXPECT_GT(compareKeys(maxKey, stringKey), 0);
+    EXPECT_GT(compareKeys(maxKey, numberKey), 0);
+    EXPECT_GT(compareKeys(maxKey, dateKey), 0);
 }
 
 TEST(IDBLevelDBCodingTest, MinIDBKey)
 {
     Vector<char> minKey = minIDBKey();
 
     Vector<char> maxKey = maxIDBKey();
     Vector<char> arrayKey = encodeIDBKey(*IDBKey::createArray(IDBKey::KeyArray()));
     Vector<char> stringKey = encodeIDBKey(*IDBKey::createString("Hello world"));
     Vector<char> numberKey = encodeIDBKey(*IDBKey::createNumber(3.14));
     Vector<char> dateKey = encodeIDBKey(*IDBKey::createDate(1000000));
 
-    EXPECT_LT(compareEncodedIDBKeys(minKey, maxKey), 0);
-    EXPECT_LT(compareEncodedIDBKeys(minKey, arrayKey), 0);
-    EXPECT_LT(compareEncodedIDBKeys(minKey, stringKey), 0);
-    EXPECT_LT(compareEncodedIDBKeys(minKey, numberKey), 0);
-    EXPECT_LT(compareEncodedIDBKeys(minKey, dateKey), 0);
+    EXPECT_LT(compareKeys(minKey, maxKey), 0);
+    EXPECT_LT(compareKeys(minKey, arrayKey), 0);
+    EXPECT_LT(compareKeys(minKey, stringKey), 0);
+    EXPECT_LT(compareKeys(minKey, numberKey), 0);
+    EXPECT_LT(compareKeys(minKey, dateKey), 0);
 }
 
 TEST(IDBLevelDBCodingTest, EncodeInt)
 {
     EXPECT_EQ(static_cast<size_t>(1), encodeInt(0).size());
     EXPECT_EQ(static_cast<size_t>(1), encodeInt(1).size());
     EXPECT_EQ(static_cast<size_t>(1), encodeInt(255).size());
     EXPECT_EQ(static_cast<size_t>(2), encodeInt(256).size());
     EXPECT_EQ(static_cast<size_t>(4), encodeInt(0xffffffff).size());
 #ifdef NDEBUG
@@ skipping 154 matching lines @@
         EXPECT_EQ(s, res);
         EXPECT_EQ(v.data() + v.size(), p);
 
         EXPECT_EQ(0, decodeStringWithLength(v.data(), v.data() + v.size() - 1, res));
         EXPECT_EQ(0, decodeStringWithLength(v.data(), v.data(), res));
     }
 }
 
 static int compareStrings(const char* p, const char* limitP, const char* q, const char* limitQ)
 {
-    int result = compareEncodedStringsWithLength(p, limitP, q, limitQ);
+    bool ok;
+    int result = compareEncodedStringsWithLength(p, limitP, q, limitQ, ok);
+    EXPECT_TRUE(ok);
     EXPECT_EQ(p, limitP);
     EXPECT_EQ(q, limitQ);
     return result;
 }
 
 TEST(IDBLevelDBCodingTest, CompareEncodedStringsWithLength)
 {
     const UChar testStringA[] = {0x1000, 0x1000, '\0'};
     const UChar testStringB[] = {0x1000, 0x1000, 0x1000, '\0'};
     const UChar testStringC[] = {0x1000, 0x1000, 0x1001, '\0'};
@@ skipping 288 matching lines @@
         Vector<char> extractedB;
 
         const char* p = extractEncodedIDBKey(encodedA.data(), encodedA.data() + encodedA.size(), &extractedA);
         EXPECT_EQ(encodedA.data() + encodedA.size(), p);
         EXPECT_EQ(encodedA, extractedA);
 
         const char* q = extractEncodedIDBKey(encodedB.data(), encodedB.data() + encodedB.size(), &extractedB);
         EXPECT_EQ(encodedB.data() + encodedB.size(), q);
         EXPECT_EQ(encodedB, extractedB);
 
-        EXPECT_LT(compareEncodedIDBKeys(extractedA, extractedB), 0);
-        EXPECT_GT(compareEncodedIDBKeys(extractedB, extractedA), 0);
-        EXPECT_EQ(compareEncodedIDBKeys(extractedA, extractedA), 0);
-        EXPECT_EQ(compareEncodedIDBKeys(extractedB, extractedB), 0);
+        EXPECT_LT(compareKeys(extractedA, extractedB), 0);
+        EXPECT_GT(compareKeys(extractedB, extractedA), 0);
+        EXPECT_EQ(compareKeys(extractedA, extractedA), 0);
+        EXPECT_EQ(compareKeys(extractedB, extractedB), 0);
 
         EXPECT_EQ(0, extractEncodedIDBKey(encodedA.data(), encodedA.data() + encodedA.size() - 1, &extractedA));
     }
 }
 
 TEST(IDBLevelDBCodingTest, ComparisonTest)
 {
     Vector<Vector<char> > keys;
     keys.append(SchemaVersionKey::encode());
     keys.append(MaxDatabaseIdKey::encode());
@@ skipping 82 matching lines @@
 
         EXPECT_EQ(vA.size(), vB.size());
         EXPECT_EQ(*(vA.data()), *(vB.data()));
     }
 }
 
 } // namespace
 
 #endif // USE(LEVELDB)
 #endif // ENABLE(INDEXED_DATABASE)