forked from blue/lmdbal
281 lines
8.1 KiB
C++
281 lines
8.1 KiB
C++
#include <gtest/gtest.h>
|
|
|
|
#include "base.h"
|
|
#include "storage.h"
|
|
#include "cache.h"
|
|
|
|
#include <QString>
|
|
|
|
class BaseTest : public ::testing::Test {
|
|
protected:
|
|
BaseTest():
|
|
::testing::Test(),
|
|
t1(db->getStorage<uint32_t, uint32_t>("table1")),
|
|
t2(db->getStorage<QString, QString>("table2")),
|
|
c1(db->getCache<int8_t, std::string>("cache1")) {}
|
|
|
|
~BaseTest() {}
|
|
|
|
static void SetUpTestSuite() {
|
|
if (db == nullptr) {
|
|
db = new LMDBAL::Base("testBase");
|
|
db->addStorage<uint32_t, uint32_t>("table1");
|
|
db->addStorage<QString, QString>("table2");
|
|
db->addCache<int8_t, std::string>("cache1");
|
|
}
|
|
}
|
|
|
|
static void TearDownTestSuite() {
|
|
db->close();
|
|
db->removeDirectory();
|
|
delete db;
|
|
db = nullptr;
|
|
}
|
|
|
|
static LMDBAL::Base* db;
|
|
|
|
LMDBAL::Storage<uint32_t, uint32_t>* t1;
|
|
LMDBAL::Storage<QString, QString>* t2;
|
|
LMDBAL::Cache<int8_t, std::string>* c1;
|
|
};
|
|
|
|
|
|
LMDBAL::Base* BaseTest::db = nullptr;
|
|
|
|
TEST_F(BaseTest, RemovingDirectory) {
|
|
EXPECT_EQ(db->removeDirectory(), true);
|
|
}
|
|
|
|
TEST_F(BaseTest, OpeningClosingDatabase) {
|
|
EXPECT_EQ(db->ready(), false);
|
|
db->open();
|
|
EXPECT_EQ(db->ready(), true);
|
|
db->close();
|
|
EXPECT_EQ(db->ready(), false);
|
|
db->open();
|
|
EXPECT_EQ(db->ready(), true);
|
|
}
|
|
|
|
TEST_F(BaseTest, AddingIntegerKey) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
t1->addRecord(1, 2);
|
|
t1->addRecord(2, 2);
|
|
t1->addRecord(3, 15);
|
|
EXPECT_EQ(t1->getRecord(1), 2);
|
|
}
|
|
|
|
TEST_F(BaseTest, AddingQStringKey) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
t2->addRecord("hello", "world");
|
|
t2->addRecord("aaa", "gagdfsdf");
|
|
t2->addRecord("sdfhga", "DSFFDG");
|
|
t2->addRecord("sdfsda", "shgsdgfa");
|
|
EXPECT_EQ(t2->getRecord("hello"), "world");
|
|
}
|
|
|
|
TEST_F(BaseTest, AddingKeysToCache) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
c1->addRecord(2, "blah balah");
|
|
c1->addRecord(-4, "testing goes brrr");
|
|
c1->addRecord(140, "whatever");
|
|
c1->addRecord(-37, "aaaaa tss tsss tsss tsss aaaaaaa");
|
|
EXPECT_EQ(c1->getRecord(140), "whatever");
|
|
EXPECT_EQ(c1->getRecord(-116), "whatever");
|
|
}
|
|
|
|
TEST_F(BaseTest, AddingRepeatingIntegerKey) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
bool thrown = false;
|
|
try {
|
|
t1->addRecord(3, 24);
|
|
} catch (const LMDBAL::Exist e) {
|
|
thrown = true;
|
|
}
|
|
ASSERT_EQ(thrown, true) << "The expected behaviour is to throw exception on duplicate, but it didn't happened";
|
|
EXPECT_EQ(t1->getRecord(3), 15);
|
|
}
|
|
|
|
TEST_F(BaseTest, AddingRepeatingStringKey) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
bool thrown = false;
|
|
try {
|
|
t2->addRecord("sdfhga", "world");
|
|
} catch (const LMDBAL::Exist e) {
|
|
thrown = true;
|
|
}
|
|
ASSERT_EQ(thrown, true) << "The expected behaviour is to throw exception on duplicate, but it didn't happened";
|
|
EXPECT_EQ(t2->getRecord("sdfhga"), "DSFFDG");
|
|
}
|
|
|
|
TEST_F(BaseTest, AddingRepeatingCacheKey) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
bool thrown = false;
|
|
try {
|
|
c1->addRecord(-4, "world");
|
|
} catch (const LMDBAL::Exist e) {
|
|
thrown = true;
|
|
}
|
|
ASSERT_EQ(thrown, true) << "The expected behaviour is to throw exception on duplicate, but it didn't happened";
|
|
EXPECT_EQ(c1->getRecord(-4), "testing goes brrr");
|
|
}
|
|
|
|
TEST_F(BaseTest, GettingNotExistingKeys) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
bool thrown = false;
|
|
try {
|
|
QString wrong = t2->getRecord("almonds");
|
|
} catch (const LMDBAL::NotFound e) {
|
|
thrown = true;
|
|
}
|
|
ASSERT_EQ(thrown, true) << "The expected behaviour is to throw exception on duplicate, but it didn't happened";
|
|
|
|
thrown = false;
|
|
try {
|
|
uint32_t wrong = t1->getRecord(64);
|
|
} catch (const LMDBAL::NotFound e) {
|
|
thrown = true;
|
|
}
|
|
ASSERT_EQ(thrown, true) << "The expected behaviour is to throw exception on duplicate, but it didn't happened";
|
|
|
|
thrown = false;
|
|
try {
|
|
std::string wrong = c1->getRecord(21);
|
|
} catch (const LMDBAL::NotFound e) {
|
|
thrown = true;
|
|
}
|
|
ASSERT_EQ(thrown, true) << "The expected behaviour is to throw exception on duplicate, but it didn't happened";
|
|
}
|
|
|
|
TEST_F(BaseTest, Persistence) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
db->close();
|
|
delete db;
|
|
|
|
db = new LMDBAL::Base("testBase");
|
|
t1 = db->addStorage<uint32_t, uint32_t>("table1");
|
|
t2 = db->addStorage<QString, QString>("table2");
|
|
c1 = db->addCache<int8_t, std::string>("cache1");
|
|
db->open();
|
|
|
|
EXPECT_EQ(t1->getRecord(3), 15);
|
|
EXPECT_EQ(t1->getRecord(1), 2);
|
|
EXPECT_EQ(t1->getRecord(2), 2);
|
|
|
|
EXPECT_EQ(t2->getRecord("hello"), "world");
|
|
EXPECT_EQ(t2->getRecord("aaa"), "gagdfsdf");
|
|
EXPECT_EQ(t2->getRecord("sdfhga"), "DSFFDG");
|
|
EXPECT_EQ(t2->getRecord("sdfsda"), "shgsdgfa");
|
|
|
|
EXPECT_EQ(c1->getRecord(-116), "whatever");
|
|
EXPECT_EQ(c1->getRecord(-4), "testing goes brrr");
|
|
EXPECT_EQ(c1->getRecord(-4), "testing goes brrr");
|
|
EXPECT_EQ(c1->getRecord(-37), "aaaaa tss tsss tsss tsss aaaaaaa");
|
|
EXPECT_EQ(c1->getRecord(2), "blah balah");
|
|
|
|
bool thrown = false;
|
|
try {
|
|
QString wrong = t2->getRecord("cats");
|
|
} catch (const LMDBAL::NotFound e) {
|
|
thrown = true;
|
|
}
|
|
ASSERT_EQ(thrown, true) << "The expected behaviour is to throw exception on duplicate, but it didn't happened";
|
|
|
|
thrown = false;
|
|
try {
|
|
uint32_t wrong = t1->getRecord(7893);
|
|
} catch (const LMDBAL::NotFound e) {
|
|
thrown = true;
|
|
}
|
|
ASSERT_EQ(thrown, true) << "The expected behaviour is to throw exception on duplicate, but it didn't happened";
|
|
|
|
thrown = false;
|
|
try {
|
|
std::string wrong = c1->getRecord(89);
|
|
} catch (const LMDBAL::NotFound e) {
|
|
thrown = true;
|
|
}
|
|
ASSERT_EQ(thrown, true) << "The expected behaviour is to throw exception on duplicate, but it didn't happened";
|
|
}
|
|
|
|
TEST_F(BaseTest, CountAndDrop) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
EXPECT_EQ(t1->count(), 3);
|
|
EXPECT_EQ(t2->count(), 4);
|
|
EXPECT_EQ(c1->count(), 4);
|
|
|
|
db->drop();
|
|
|
|
EXPECT_EQ(t1->count(), 0);
|
|
EXPECT_EQ(t2->count(), 0);
|
|
EXPECT_EQ(c1->count(), 0);
|
|
|
|
t1->addRecord(2, 2);
|
|
t2->addRecord("sdfhga", "world");
|
|
c1->addRecord(15, "world");
|
|
c1->addRecord(12, "grr grr");
|
|
|
|
EXPECT_EQ(t1->count(), 1);
|
|
EXPECT_EQ(t2->count(), 1);
|
|
EXPECT_EQ(c1->count(), 2);
|
|
}
|
|
|
|
TEST_F(BaseTest, Change) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
EXPECT_EQ(t1->count(), 1);
|
|
EXPECT_EQ(t2->count(), 1);
|
|
EXPECT_EQ(c1->count(), 2);
|
|
|
|
EXPECT_EQ(t1->getRecord(2), 2);
|
|
EXPECT_EQ(t2->getRecord("sdfhga"), "world");
|
|
EXPECT_EQ(c1->getRecord(15), "world");
|
|
EXPECT_EQ(c1->getRecord(12), "grr grr");
|
|
|
|
t1->addRecord(58, 39);
|
|
t2->addRecord("lawfirm", "stumble");
|
|
c1->addRecord(89, "answer");
|
|
|
|
t1->changeRecord(2, 49);
|
|
t2->changeRecord("sdfhga", "void");
|
|
c1->changeRecord(15, "recording");
|
|
c1->changeRecord(12, "thermal");
|
|
|
|
EXPECT_EQ(t1->getRecord(2), 49);
|
|
EXPECT_EQ(t2->getRecord("sdfhga"), "void");
|
|
EXPECT_EQ(c1->getRecord(15), "recording");
|
|
EXPECT_EQ(c1->getRecord(12), "thermal");
|
|
|
|
EXPECT_EQ(t1->getRecord(58), 39);
|
|
EXPECT_EQ(t2->getRecord("lawfirm"), "stumble");
|
|
EXPECT_EQ(c1->getRecord(89), "answer");
|
|
|
|
EXPECT_EQ(t1->count(), 2);
|
|
EXPECT_EQ(t2->count(), 2);
|
|
EXPECT_EQ(c1->count(), 3);
|
|
}
|
|
|
|
TEST_F(BaseTest, Force) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
|
|
t1->forceRecord(58, 35); //changing
|
|
t1->forceRecord(68, 36); //adding
|
|
t2->forceRecord("prophecy", "dumpling"); //adding
|
|
t2->forceRecord("lawfirm", "paracetamol"); //changing
|
|
c1->forceRecord(89, "canine"); //changing
|
|
c1->forceRecord(98, "duration"); //adding
|
|
|
|
EXPECT_EQ(t1->getRecord(2), 49);
|
|
EXPECT_EQ(t1->getRecord(58), 35);
|
|
EXPECT_EQ(t1->getRecord(68), 36);
|
|
EXPECT_EQ(t2->getRecord("sdfhga"), "void");
|
|
EXPECT_EQ(t2->getRecord("prophecy"), "dumpling");
|
|
EXPECT_EQ(t2->getRecord("lawfirm"), "paracetamol");
|
|
EXPECT_EQ(c1->getRecord(15), "recording");
|
|
EXPECT_EQ(c1->getRecord(12), "thermal");
|
|
EXPECT_EQ(c1->getRecord(89), "canine");
|
|
EXPECT_EQ(c1->getRecord(98), "duration");
|
|
|
|
EXPECT_EQ(t1->count(), 3);
|
|
EXPECT_EQ(t2->count(), 3);
|
|
EXPECT_EQ(c1->count(), 4);
|
|
}
|