Check Integer properly sorted and null terminated strings

1 files changed, 106 insertions, 3 deletions

diff --git a/tests/storagetest.cpp b/tests/storagetest.cpp
index 925d1d9..3d583ab 100644
--- a/tests/storagetest.cpp
+++ b/tests/storagetest.cpp
@@ -792,14 +792,28 @@ private slots:
         auto db = transaction.openDatabase("testIntegerKeys", {}, flags);
         db.write(0, "value1");
         db.write(1, "value2");
+
+        size_t resultKey;
         QByteArray result;
-        int numValues = db.scan(0, [&](size_t, const QByteArray &value) -> bool {
+        int numValues = db.scan(0, [&](size_t key, const QByteArray &value) -> bool {
+            resultKey = key;
             result = value;
             return true;
         });
 
         QCOMPARE(numValues, 1);
+        QCOMPARE(resultKey, 0);
         QCOMPARE(result, "value1");
+
+        int numValues2 = db.scan(1, [&](size_t key, const QByteArray &value) -> bool {
+            resultKey = key;
+            result = value;
+            return true;
+        });
+
+        QCOMPARE(numValues2, 1);
+        QCOMPARE(resultKey, 1);
+        QCOMPARE(result, "value2");
     }
 
     void testDuplicateIntegerKeys()
@@ -853,8 +867,97 @@ private slots:
 
         QCOMPARE(numValues, 2);
         QCOMPARE(results.size(), 2);
-        QVERIFY(results[0] == number1BA);
-        QVERIFY(results[1] == number2BA);
+        QCOMPARE(results[0], number1BA);
+        QCOMPARE(results[1], number2BA);
+    }
+
+    void testIntegerKeyMultipleOf256()
+    {
+        const int flags = Sink::Storage::IntegerKeys;
+        Sink::Storage::DataStore store(testDataPath,
+                { dbName, { {"testIntegerKeyMultipleOf256", flags} } },
+                Sink::Storage::DataStore::ReadWrite);
+
+        {
+            auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
+            auto db = transaction.openDatabase("testIntegerKeyMultipleOf256", {}, flags);
+
+            db.write(0x100, "hello");
+            db.write(0x200, "hello2");
+            db.write(0x42, "hello3");
+
+            transaction.commit();
+        }
+
+        {
+            auto transaction2 = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
+            auto db = transaction2.openDatabase("testIntegerKeyMultipleOf256", {}, flags);
+
+            size_t resultKey;
+            QByteArray resultValue;
+            db.scan(0x100, [&] (size_t key, const QByteArray &value) {
+                resultKey = key;
+                resultValue = value;
+                return false;
+            });
+
+            QCOMPARE(resultKey, 0x100);
+            QCOMPARE(resultValue, "hello");
+        }
+    }
+
+    void testIntegerProperlySorted()
+    {
+        const int flags = Sink::Storage::IntegerKeys;
+        Sink::Storage::DataStore store(testDataPath,
+                { dbName, { {"testIntegerProperlySorted", flags} } },
+                Sink::Storage::DataStore::ReadWrite);
+
+        {
+            auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
+            auto db = transaction.openDatabase("testIntegerProperlySorted", {}, flags);
+
+            for (size_t i = 0; i < 0x100; ++i) {
+                db.write(i, "hello");
+            }
+
+            size_t previous = 0;
+            bool success = true;
+            db.scan("", [&] (const QByteArray &key, const QByteArray &value) {
+                size_t current = Sink::byteArrayToSizeT(key);
+                if (current < previous) {
+                    success = false;
+                    return false;
+                }
+
+                previous = current;
+                return true;
+            });
+
+            QVERIFY2(success, "Integer are not properly sorted before commit");
+
+            transaction.commit();
+        }
+
+        {
+            auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
+            auto db = transaction.openDatabase("testIntegerProperlySorted", {}, flags);
+
+            size_t previous = 0;
+            bool success = true;
+            db.scan("", [&] (const QByteArray &key, const QByteArray &value) {
+                size_t current = Sink::byteArrayToSizeT(key);
+                if (current < previous) {
+                    success = false;
+                    return false;
+                }
+
+                previous = current;
+                return true;
+            });
+
+            QVERIFY2(success, "Integer are not properly sorted after commit");
+        }
     }
 
 };