476 lines
14 KiB
C++
476 lines
14 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() {}
|
|
|
|
uint32_t getT1Flags() const {return t1->flags();}
|
|
uint32_t getT2Flags() const {return t2->flags();}
|
|
uint32_t getC1Flags() const {return c1->flags();}
|
|
|
|
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, Flags) {
|
|
uint32_t t1Flags = getT1Flags();
|
|
uint32_t t2Flags = getT2Flags();
|
|
uint32_t c1Flags = getC1Flags();
|
|
|
|
EXPECT_TRUE(t1Flags & MDB_INTEGERKEY);
|
|
EXPECT_FALSE(t1Flags & MDB_DUPSORT);
|
|
EXPECT_FALSE(t1Flags & MDB_DUPFIXED);
|
|
EXPECT_FALSE(t1Flags & MDB_INTEGERDUP);
|
|
|
|
EXPECT_FALSE(t2Flags & MDB_INTEGERKEY);
|
|
EXPECT_FALSE(t2Flags & MDB_DUPSORT);
|
|
EXPECT_FALSE(t2Flags & MDB_DUPFIXED);
|
|
EXPECT_FALSE(t2Flags & MDB_INTEGERDUP);
|
|
|
|
EXPECT_TRUE(c1Flags & MDB_INTEGERKEY);
|
|
EXPECT_FALSE(c1Flags & MDB_DUPSORT);
|
|
EXPECT_FALSE(c1Flags & MDB_DUPFIXED);
|
|
EXPECT_FALSE(c1Flags & MDB_INTEGERDUP);
|
|
}
|
|
|
|
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, AddingRepeatingKey) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
|
|
EXPECT_THROW(t1->addRecord(3, 24), LMDBAL::Exist);
|
|
EXPECT_EQ(t1->getRecord(3), 15);
|
|
|
|
EXPECT_THROW(t2->addRecord("sdfhga", "world"), LMDBAL::Exist);
|
|
EXPECT_EQ(t2->getRecord("sdfhga"), "DSFFDG");
|
|
|
|
EXPECT_THROW(c1->addRecord(-4, "world"), LMDBAL::Exist);
|
|
EXPECT_EQ(c1->getRecord(-4), "testing goes brrr");
|
|
}
|
|
|
|
TEST_F(BaseTest, GettingNotExistingKeys) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
|
|
EXPECT_THROW(t2->getRecord("almonds"), LMDBAL::NotFound);
|
|
EXPECT_THROW(t1->getRecord(64), LMDBAL::NotFound);
|
|
EXPECT_THROW(c1->getRecord(21), LMDBAL::NotFound);
|
|
}
|
|
|
|
TEST_F(BaseTest, Persistence) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
uint32_t t1Size = t1->count();
|
|
uint32_t t2Size = t2->count();
|
|
uint32_t c1Size = c1->count();
|
|
|
|
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->count(), t1Size);
|
|
EXPECT_EQ(t1->getRecord(3), 15);
|
|
EXPECT_EQ(t1->getRecord(1), 2);
|
|
EXPECT_EQ(t1->getRecord(2), 2);
|
|
EXPECT_EQ(t1->count(), t1Size);
|
|
|
|
|
|
EXPECT_EQ(t2->count(), t2Size);
|
|
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(t2->count(), t2Size);
|
|
|
|
EXPECT_EQ(c1->count(), c1Size);
|
|
EXPECT_EQ(c1->checkRecord(-116), true);
|
|
EXPECT_EQ(c1->getRecord(-116), "whatever");
|
|
EXPECT_EQ(c1->checkRecord(-4), true);
|
|
EXPECT_EQ(c1->getRecord(-4), "testing goes brrr");
|
|
EXPECT_EQ(c1->getRecord(-4), "testing goes brrr");
|
|
EXPECT_EQ(c1->checkRecord(-4), true);
|
|
EXPECT_EQ(c1->count(), c1Size);
|
|
EXPECT_EQ(c1->getRecord(-37), "aaaaa tss tsss tsss tsss aaaaaaa");
|
|
EXPECT_EQ(c1->getRecord(2), "blah balah");
|
|
EXPECT_EQ(c1->count(), c1Size);
|
|
|
|
EXPECT_THROW(t2->getRecord("cats"), LMDBAL::NotFound);
|
|
EXPECT_THROW(t1->getRecord(7893), LMDBAL::NotFound);
|
|
EXPECT_THROW(c1->getRecord(89), LMDBAL::NotFound);
|
|
}
|
|
|
|
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_THROW(t1->changeRecord(37, 49), LMDBAL::NotFound);
|
|
EXPECT_THROW(t2->changeRecord("precision", "cryoplastics"), LMDBAL::NotFound);
|
|
EXPECT_THROW(c1->changeRecord(-62, "sharks"), LMDBAL::NotFound);
|
|
|
|
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);
|
|
|
|
EXPECT_EQ(t1->forceRecord(58, 35), false); //changing
|
|
EXPECT_EQ(t1->forceRecord(68, 36), true); //adding
|
|
EXPECT_EQ(t2->forceRecord("prophecy", "dumpling"), true); //adding
|
|
EXPECT_EQ(t2->forceRecord("lawfirm", "paracetamol"), false); //changing
|
|
EXPECT_EQ(c1->forceRecord(89, "canine"), false); //changing
|
|
EXPECT_EQ(c1->forceRecord(98, "duration"), true); //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);
|
|
}
|
|
|
|
TEST_F(BaseTest, ReadAll) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
|
|
std::map<uint32_t, uint32_t> m1 = t1->readAll();
|
|
std::map<QString, QString> m2 = t2->readAll();
|
|
std::map<int8_t, std::string> m3 = c1->readAll();
|
|
|
|
EXPECT_EQ(m1.at(2), 49);
|
|
EXPECT_EQ(m1.at(58), 35);
|
|
EXPECT_EQ(m1.at(68), 36);
|
|
EXPECT_EQ(m2.at("sdfhga"), "void");
|
|
EXPECT_EQ(m2.at("prophecy"), "dumpling");
|
|
EXPECT_EQ(m2.at("lawfirm"), "paracetamol");
|
|
EXPECT_EQ(m3.at(15), "recording");
|
|
EXPECT_EQ(m3.at(12), "thermal");
|
|
EXPECT_EQ(m3.at(89), "canine");
|
|
EXPECT_EQ(m3.at(98), "duration");
|
|
|
|
EXPECT_EQ(m1.size(), 3);
|
|
EXPECT_EQ(m2.size(), 3);
|
|
EXPECT_EQ(m3.size(), 4);
|
|
}
|
|
|
|
TEST_F(BaseTest, ReplaceAll) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
|
|
t1->replaceAll({
|
|
{7, 48},
|
|
{194, 582},
|
|
{857, 39},
|
|
{9717, 8}
|
|
});
|
|
t2->replaceAll({
|
|
{"bringin", "keyboard"},
|
|
{"cluster", "throttle"},
|
|
{"ronin", "cheese"}
|
|
});
|
|
c1->replaceAll({});
|
|
|
|
EXPECT_EQ(t1->count(), 4);
|
|
EXPECT_EQ(t2->count(), 3);
|
|
EXPECT_EQ(c1->count(), 0);
|
|
|
|
EXPECT_FALSE(t1->checkRecord(2));
|
|
EXPECT_FALSE(t1->checkRecord(58));
|
|
EXPECT_FALSE(t1->checkRecord(68));
|
|
|
|
EXPECT_FALSE(t2->checkRecord("sdfhga"));
|
|
EXPECT_FALSE(t2->checkRecord("prophecy"));
|
|
EXPECT_FALSE(t2->checkRecord("lawfirm"));
|
|
|
|
EXPECT_FALSE(c1->checkRecord(15));
|
|
EXPECT_FALSE(c1->checkRecord(12));
|
|
EXPECT_FALSE(c1->checkRecord(89));
|
|
EXPECT_FALSE(c1->checkRecord(98));
|
|
|
|
EXPECT_EQ(t1->getRecord(7), 48);
|
|
EXPECT_EQ(t1->getRecord(194), 582);
|
|
EXPECT_EQ(t1->getRecord(857), 39);
|
|
EXPECT_EQ(t1->getRecord(9717), 8);
|
|
|
|
EXPECT_EQ(t2->getRecord("bringin"), "keyboard");
|
|
EXPECT_EQ(t2->getRecord("cluster"), "throttle");
|
|
EXPECT_EQ(t2->getRecord("ronin"), "cheese");
|
|
|
|
c1->replaceAll({
|
|
{68, "quality"},
|
|
{31, "ridgid body"},
|
|
{16, "fermentation on your kind"},
|
|
{22, "pseudo"},
|
|
{-117, "lance of Michael"},
|
|
});
|
|
EXPECT_EQ(c1->count(), 5);
|
|
|
|
EXPECT_EQ(c1->getRecord(68), "quality");
|
|
EXPECT_EQ(c1->getRecord(31), "ridgid body");
|
|
EXPECT_EQ(c1->getRecord(16), "fermentation on your kind");
|
|
EXPECT_EQ(c1->getRecord(22), "pseudo");
|
|
EXPECT_EQ(c1->getRecord(-117), "lance of Michael");
|
|
}
|
|
|
|
|
|
|
|
TEST_F(BaseTest, AddRecords) {
|
|
EXPECT_EQ(db->ready(), true);
|
|
|
|
LMDBAL::SizeType s1 = t1->addRecords({
|
|
{5, 3},
|
|
{800, 9}
|
|
});
|
|
EXPECT_EQ(s1, 6);
|
|
EXPECT_EQ(t1->getRecord(7), 48);
|
|
EXPECT_EQ(t1->getRecord(194), 582);
|
|
EXPECT_EQ(t1->getRecord(857), 39);
|
|
EXPECT_EQ(t1->getRecord(9717), 8);
|
|
EXPECT_EQ(t1->getRecord(5), 3);
|
|
EXPECT_EQ(t1->getRecord(800), 9);
|
|
s1 = t1->addRecords({
|
|
{194, 371},
|
|
{808, 487},
|
|
{807, 0}
|
|
}, true);
|
|
EXPECT_EQ(s1, 8);
|
|
EXPECT_EQ(t1->count(), 8);
|
|
EXPECT_EQ(t1->getRecord(7), 48);
|
|
EXPECT_EQ(t1->getRecord(194), 371);
|
|
EXPECT_EQ(t1->getRecord(857), 39);
|
|
EXPECT_EQ(t1->getRecord(9717), 8);
|
|
EXPECT_EQ(t1->getRecord(5), 3);
|
|
EXPECT_EQ(t1->getRecord(800), 9);
|
|
EXPECT_EQ(t1->getRecord(808), 487);
|
|
EXPECT_EQ(t1->getRecord(807), 0);
|
|
EXPECT_THROW(
|
|
s1 = t1->addRecords({
|
|
{194, 371},
|
|
{808, 487},
|
|
{807, 0}
|
|
}), LMDBAL::Exist
|
|
);
|
|
EXPECT_EQ(t1->count(), 8);
|
|
|
|
LMDBAL::SizeType s2 = t2->addRecords({
|
|
{"lama", "not quite"},
|
|
{"by the shadow", "leech"},
|
|
{"summertime", "curses"}
|
|
});
|
|
EXPECT_EQ(s2, 6);
|
|
EXPECT_EQ(t2->count(), 6);
|
|
EXPECT_EQ(t2->getRecord("bringin"), "keyboard");
|
|
EXPECT_EQ(t2->getRecord("cluster"), "throttle");
|
|
EXPECT_EQ(t2->getRecord("ronin"), "cheese");
|
|
EXPECT_EQ(t2->getRecord("lama"), "not quite");
|
|
EXPECT_EQ(t2->getRecord("by the shadow"), "leech");
|
|
EXPECT_EQ(t2->getRecord("summertime"), "curses");
|
|
s2 = t2->addRecords({
|
|
{"worry not", "for shall you"},
|
|
{"by the shadow", "face the inevitable"},
|
|
{"cluster", "sobing over those"}
|
|
}, true);
|
|
|
|
EXPECT_EQ(s2, 7);
|
|
EXPECT_EQ(t2->count(), 7);
|
|
EXPECT_EQ(t2->getRecord("bringin"), "keyboard");
|
|
EXPECT_EQ(t2->getRecord("cluster"), "sobing over those");
|
|
EXPECT_EQ(t2->getRecord("ronin"), "cheese");
|
|
EXPECT_EQ(t2->getRecord("lama"), "not quite");
|
|
EXPECT_EQ(t2->getRecord("by the shadow"), "face the inevitable");
|
|
EXPECT_EQ(t2->getRecord("summertime"), "curses");
|
|
EXPECT_EQ(t2->getRecord("worry not"), "for shall you");
|
|
|
|
EXPECT_THROW(
|
|
s2 = t2->addRecords({
|
|
{"within reasonable limits", "occasion"},
|
|
{"ronin", "crest of violence"},
|
|
{"permanent", "of your kind"}
|
|
}), LMDBAL::Exist
|
|
);
|
|
EXPECT_EQ(t2->count(), 7);
|
|
|
|
LMDBAL::SizeType s3 = c1->addRecords({
|
|
{19, "menace"},
|
|
{-7, "failure driven sorrow"},
|
|
{82, "lungache"},
|
|
{4, "drowsy"},
|
|
{44, "pressure"},
|
|
});
|
|
|
|
EXPECT_EQ(c1->count(), 10);
|
|
EXPECT_EQ(s3, 10);
|
|
|
|
EXPECT_EQ(c1->getRecord(68), "quality");
|
|
EXPECT_EQ(c1->getRecord(31), "ridgid body");
|
|
EXPECT_EQ(c1->getRecord(16), "fermentation on your kind");
|
|
EXPECT_EQ(c1->getRecord(22), "pseudo");
|
|
EXPECT_EQ(c1->getRecord(-117), "lance of Michael");
|
|
EXPECT_EQ(c1->getRecord(19), "menace");
|
|
EXPECT_EQ(c1->getRecord(-7), "failure driven sorrow");
|
|
EXPECT_EQ(c1->getRecord(82), "lungache");
|
|
EXPECT_EQ(c1->getRecord(4), "drowsy");
|
|
EXPECT_EQ(c1->getRecord(44), "pressure");
|
|
|
|
EXPECT_THROW(
|
|
s3 = c1->addRecords({
|
|
{-72, "amber"},
|
|
{-9, "going swinging of paleopathy"},
|
|
{82, "regret"}
|
|
}), LMDBAL::Exist
|
|
);
|
|
EXPECT_EQ(c1->count(), 10);
|
|
|
|
s3 = c1->addRecords({
|
|
{19, "to replicated being"},
|
|
{123, "horibly unforseen"},
|
|
{-32, "stitched"},
|
|
{31, "overall"}
|
|
}, true);
|
|
EXPECT_EQ(c1->count(), 12);
|
|
EXPECT_EQ(s3, 12);
|
|
EXPECT_EQ(c1->getRecord(68), "quality");
|
|
EXPECT_EQ(c1->getRecord(31), "overall");
|
|
EXPECT_EQ(c1->getRecord(16), "fermentation on your kind");
|
|
EXPECT_EQ(c1->getRecord(22), "pseudo");
|
|
EXPECT_EQ(c1->getRecord(-117), "lance of Michael");
|
|
EXPECT_EQ(c1->getRecord(19), "to replicated being");
|
|
EXPECT_EQ(c1->getRecord(-7), "failure driven sorrow");
|
|
EXPECT_EQ(c1->getRecord(82), "lungache");
|
|
EXPECT_EQ(c1->getRecord(4), "drowsy");
|
|
EXPECT_EQ(c1->getRecord(44), "pressure");
|
|
EXPECT_EQ(c1->getRecord(-32), "stitched");
|
|
EXPECT_EQ(c1->getRecord(123), "horibly unforseen");
|
|
|
|
}
|