4 files changed, 302 insertions, 0 deletions

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
new file mode 100644
index 0000000..1629acb
--- /dev/null
+++ b/tests/CMakeLists.txt
@@ -0,0 +1,17 @@
+set(CMAKE_AUTOMOC ON)
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+generate_flatbuffers(calendar)
+
+macro(manual_tests)
+    foreach(_testname ${ARGN})
+        add_executable(${_testname} ${_testname}.cpp)
+        qt5_use_modules(${_testname} Core Test Concurrent)
+        target_link_libraries(${_testname} akonadinextcommon)
+    endforeach(_testname)
+endmacro(manual_tests)
+
+manual_tests (
+    storagebenchmark
+    storagetest
+)
diff --git a/tests/calendar.fbs b/tests/calendar.fbs
new file mode 100644
index 0000000..203ee43
--- /dev/null
+++ b/tests/calendar.fbs
@@ -0,0 +1,12 @@
+// example IDL file
+
+namespace Calendar;
+
+table Event {
+  summary:string;
+  description:string;
+  attachment:[byte];
+}
+
+root_type Event;
+file_identifier "AKFB";
diff --git a/tests/storagebenchmark.cpp b/tests/storagebenchmark.cpp
new file mode 100644
index 0000000..f9fea7c
--- /dev/null
+++ b/tests/storagebenchmark.cpp
@@ -0,0 +1,161 @@
+#include <QtTest>
+
+#include "calendar_generated.h"
+
+#include <iostream>
+#include <fstream>
+
+#include <QDebug>
+#include <QString>
+#include <QTime>
+
+#include "common/storage.h"
+
+using namespace Calendar;
+using namespace flatbuffers;
+
+static std::string createEvent()
+{
+    FlatBufferBuilder fbb;
+    {
+        auto summary = fbb.CreateString("summary");
+
+        const int attachmentSize = 1024*2; // 2KB
+        int8_t rawData[attachmentSize];
+        auto data = fbb.CreateVector(rawData, attachmentSize);
+
+        Calendar::EventBuilder eventBuilder(fbb);
+        eventBuilder.add_summary(summary);
+        eventBuilder.add_attachment(data);
+        auto eventLocation = eventBuilder.Finish();
+        FinishEventBuffer(fbb, eventLocation);
+    }
+    return std::string(reinterpret_cast<const char *>(fbb.GetBufferPointer()), fbb.GetSize());
+}
+
+// static void readEvent(const std::string &data)
+// {
+//     auto readEvent = GetEvent(data.c_str());
+//     std::cout << readEvent->summary()->c_str() << std::endl;
+// }
+
+class StorageBenchmark : public QObject
+{
+    Q_OBJECT
+private:
+    //This should point to a directory on disk and not a ramdisk (since we're measuring performance)
+    QString testDataPath;
+    QString dbName;
+    QString filePath;
+    const int count = 50000;
+
+private Q_SLOTS:
+    void initTestCase()
+    {
+        testDataPath = "./testdb";
+        dbName = "test";
+        filePath = testDataPath + "buffer.fb";
+    }
+
+    void cleanupTestCase()
+    {
+        Storage store(testDataPath, dbName);
+        store.removeFromDisk();
+    }
+
+    void testWriteRead_data()
+    {
+        QTest::addColumn<bool>("useDb");
+        QTest::addColumn<int>("count");
+
+        QTest::newRow("db, 50k") << true << count;
+        QTest::newRow("file, 50k") << false << count;
+    }
+
+    void testWriteRead()
+    {
+        QFETCH(bool, useDb);
+        QFETCH(int, count);
+
+        Storage *store = 0;
+        if (useDb) {
+            store = new Storage(testDataPath, dbName);
+        }
+
+        std::ofstream myfile;
+        myfile.open(filePath.toStdString());
+        const char *keyPrefix = "key";
+
+        QTime time;
+
+        time.start();
+        {
+            auto event = createEvent();
+            for (int i = 0; i < count; i++) {
+                if (store) {
+                    if (i % 10000 == 0) {
+                        if (i > 0) {
+                            store->commitTransaction();
+                        }
+                        store->startTransaction();
+                    }
+
+                    store->write(keyPrefix + std::to_string(i), event);
+                } else {
+                    myfile << event;
+                }
+            }
+
+            if (store) {
+                store->commitTransaction();
+            } else {
+                myfile.close();
+            }
+        }
+        const int writeDuration = time.restart();
+        qDebug() << "Writing took[ms]: " << writeDuration;
+
+        {
+            for (int i = 0; i < count; i++) {
+                if (store) {
+                    store->read(keyPrefix + std::to_string(i), [](std::string value){});
+                }
+            }
+        }
+        const int readDuration = time.restart();
+
+        if (store) {
+            qDebug() << "Reading took[ms]: " << readDuration;
+        } else {
+            qDebug() << "File reading is not implemented.";
+        }
+
+        delete store;
+    }
+
+    void testBufferCreation()
+    {
+        QTime time;
+
+        time.start();
+        {
+            for (int i = 0; i < count; i++) {
+                auto event = createEvent();
+            }
+        }
+        const int bufferDuration = time.elapsed();
+        qDebug() << "Creating buffers took[ms]: " << bufferDuration;
+    }
+
+    void testSizes()
+    {
+        Storage store(testDataPath, dbName);
+        qDebug() << "Database size [kb]: " << store.diskUsage()/1024;
+
+        QFileInfo fileInfo(filePath);
+        qDebug() << "File size [kb]: " << fileInfo.size()/1024;
+    }
+};
+
+QTEST_MAIN(StorageBenchmark)
+#include "storagebenchmark.moc"
diff --git a/tests/storagetest.cpp b/tests/storagetest.cpp
new file mode 100644
index 0000000..2b2805d
--- /dev/null
+++ b/tests/storagetest.cpp
@@ -0,0 +1,112 @@
+#include <QtTest>
+
+#include <iostream>
+
+#include <QDebug>
+#include <QString>
+#include <QtConcurrent/QtConcurrentRun>
+
+#include "common/storage.h"
+
+class StorageTest : public QObject
+{
+    Q_OBJECT
+private:
+    //This should point to a directory on disk and not a ramdisk (since we're measuring performance)
+    QString testDataPath;
+    QString dbName;
+    const char *keyPrefix = "key";
+
+    void populate(int count)
+    {
+        Storage storage(testDataPath, dbName);
+        for (int i = 0; i < count; i++) {
+            //This should perhaps become an implementation detail of the db?
+            if (i % 10000 == 0) {
+                if (i > 0) {
+                    storage.commitTransaction();
+                }
+                storage.startTransaction();
+            }
+            storage.write(keyPrefix + std::to_string(i), keyPrefix + std::to_string(i));
+        }
+        storage.commitTransaction();
+    }
+
+    bool verify(Storage &storage, int i)
+    {
+        bool success = true;
+        bool keyMatch = true;
+        const auto reference = keyPrefix + std::to_string(i);
+        success = storage.read(keyPrefix + std::to_string(i), [&error, &reference](const std::string &value) {
+            if (value != reference) {
+                qDebug() << "Mismatch while reading";
+                keyMatch = false;
+            }
+        });
+        return succes && keyMatch;
+    }
+
+private Q_SLOTS:
+    void initTestCase()
+    {
+        testDataPath = "./testdb";
+        dbName = "test";
+    }
+
+    void cleanupTestCase()
+    {
+        Database db(testDataPath, dbName);
+        db.removeFromDisk();
+    }
+
+
+    void testRead()
+    {
+        const int count = 100;
+
+        populate(count);
+
+        //ensure we can read everything back correctly
+        {
+            Database db(testDataPath, dbName);
+            for (int i = 0; i < count; i++) {
+                QVERIFY(verify(db, i));
+            }
+        }
+
+        Database db(testDataPath, dbName);
+        db.removeFromDisk();
+    }
+
+    void testConcurrentRead()
+    {
+        const int count = 10000;
+
+        populate(count);
+
+        //Try to concurrently read
+        QList<QFuture<void> > futures;
+        const int concurrencyLevel = 4;
+        for (int num = 0; num < concurrencyLevel; num++) {
+            futures << QtConcurrent::run([this, count](){
+                Database db(testDataPath, dbName);
+                for (int i = 0; i < count; i++) {
+                    if (!verify(db, i)) {
+                        qWarning() << "invalid value";
+                        break;
+                    }
+                }
+            });
+        }
+        for(auto future : futures) {
+            future.waitForFinished();
+        }
+
+        Database db(testDataPath, dbName);
+        db.removeFromDisk();
+    }
+};
+
+QTEST_MAIN(StorageTest)
+#include "storagetest.moc"