forked from blue/lmdbal
222 lines
6.3 KiB
C++
222 lines
6.3 KiB
C++
#include <gtest/gtest.h>
|
|
|
|
#include "database.h"
|
|
#include "table.h"
|
|
#include "cache.h"
|
|
|
|
#include <QString>
|
|
|
|
class DataBaseTest : public ::testing::Test {
|
|
protected:
|
|
DataBaseTest():
|
|
::testing::Test(),
|
|
t1(db->getTable<uint32_t, uint32_t>("table1")),
|
|
t2(db->getTable<QString, QString>("table2")),
|
|
c1(db->getCache<int8_t, std::string>("cache1")) {}
|
|
|
|
~DataBaseTest() {}
|
|
|
|
static void SetUpTestSuite() {
|
|
if (db == nullptr) {
|
|
db = new DataBase("testBase");
|
|
db->addTable<uint32_t, uint32_t>("table1");
|
|
db->addTable<QString, QString>("table2");
|
|
db->addCache<int8_t, std::string>("cache1");
|
|
}
|
|
}
|
|
|
|
static void TearDownTestSuite() {
|
|
db->close();
|
|
db->removeDirectory();
|
|
delete db;
|
|
db = nullptr;
|
|
}
|
|
|
|
static DataBase* db;
|
|
|
|
DataBase::Table<uint32_t, uint32_t>* t1;
|
|
DataBase::Table<QString, QString>* t2;
|
|
DataBase::Cache<int8_t, std::string>* c1;
|
|
};
|
|
|
|
|
|
DataBase* DataBaseTest::db = nullptr;
|
|
|
|
TEST_F(DataBaseTest, RemovingDirectory) {
|
|
EXPECT_EQ(db->removeDirectory(), true);
|
|
}
|
|
|
|
TEST_F(DataBaseTest, 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(DataBaseTest, 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(DataBaseTest, 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(DataBaseTest, 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(DataBaseTest, AddingRepeatingIntegerKey) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
bool thrown = false;
|
|
try {
|
|
t1->addRecord(3, 24);
|
|
} catch (const DataBase::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(DataBaseTest, AddingRepeatingStringKey) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
bool thrown = false;
|
|
try {
|
|
t2->addRecord("sdfhga", "world");
|
|
} catch (const DataBase::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(DataBaseTest, AddingRepeatingCacheKey) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
bool thrown = false;
|
|
try {
|
|
c1->addRecord(-4, "world");
|
|
} catch (const DataBase::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(DataBaseTest, GettingNotExistingKeys) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
bool thrown = false;
|
|
try {
|
|
QString wrong = t2->getRecord("almonds");
|
|
} catch (const DataBase::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 DataBase::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 DataBase::NotFound e) {
|
|
thrown = true;
|
|
}
|
|
ASSERT_EQ(thrown, true) << "The expected behaviour is to throw exception on duplicate, but it didn't happened";
|
|
}
|
|
|
|
TEST_F(DataBaseTest, Persistence) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
db->close();
|
|
delete db;
|
|
|
|
db = new DataBase("testBase");
|
|
t1 = db->addTable<uint32_t, uint32_t>("table1");
|
|
t2 = db->addTable<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 DataBase::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 DataBase::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 DataBase::NotFound e) {
|
|
thrown = true;
|
|
}
|
|
ASSERT_EQ(thrown, true) << "The expected behaviour is to throw exception on duplicate, but it didn't happened";
|
|
}
|
|
|
|
TEST_F(DataBaseTest, 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);
|
|
}
|
|
|