tests, set method, tests for set method

test/storagecursor.cpp

@@ -22,7 +22,12 @@ protected:
         }
     }
 
+    int getTableCursorsSize() const {
+        return table->cursors.size();
+    }
+
     static void TearDownTestSuite() {
+        cursor.drop();
         transaction.terminate();
         db->close();
         db->removeDirectory();
@@ -61,7 +66,9 @@ TEST_F(StorageCursorTest, PopulatingTheTable) {
 }
 
 TEST_F(StorageCursorTest, Creation) {
+    EXPECT_EQ(getTableCursorsSize(), 0);
     cursor = table->createCursor();
+    EXPECT_EQ(getTableCursorsSize(), 1);
 
     EXPECT_THROW(cursor.first(), LMDBAL::CursorNotReady);
     EXPECT_THROW(cursor.last(), LMDBAL::CursorNotReady);
@@ -73,6 +80,7 @@ TEST_F(StorageCursorTest, Creation) {
 }
 
 TEST_F(StorageCursorTest, FirstPrivate) {
+    EXPECT_EQ(getTableCursorsSize(), 1);
     std::pair<uint64_t, std::string> element = cursor.first();
     std::map<uint64_t, std::string>::const_iterator reference = data.begin();
 
@@ -81,6 +89,7 @@ TEST_F(StorageCursorTest, FirstPrivate) {
 }
 
 TEST_F(StorageCursorTest, NextPrivate) {
+    EXPECT_EQ(getTableCursorsSize(), 1);
     std::map<uint64_t, std::string>::const_iterator reference = data.begin();
 
     reference++;
@@ -100,6 +109,7 @@ TEST_F(StorageCursorTest, NextPrivate) {
 }
 
 TEST_F(StorageCursorTest, LastPrivate) {
+    EXPECT_EQ(getTableCursorsSize(), 1);
     std::pair<uint64_t, std::string> element = cursor.last();
     std::map<uint64_t, std::string>::const_reverse_iterator reference = data.rbegin();
 
@@ -108,6 +118,7 @@ TEST_F(StorageCursorTest, LastPrivate) {
 }
 
 TEST_F(StorageCursorTest, PrevPrivate) {
+    EXPECT_EQ(getTableCursorsSize(), 1);
     std::map<uint64_t, std::string>::const_reverse_iterator reference = data.rbegin();
 
     reference++;
@@ -127,6 +138,7 @@ TEST_F(StorageCursorTest, PrevPrivate) {
 }
 
 TEST_F(StorageCursorTest, CurrentPrivate) {
+    EXPECT_EQ(getTableCursorsSize(), 1);
     std::pair<uint64_t, std::string> element = cursor.first();
     std::map<uint64_t, std::string>::const_iterator reference = data.begin();
 
@@ -157,8 +169,42 @@ TEST_F(StorageCursorTest, CurrentPrivate) {
     EXPECT_EQ(element.second, reference->second);
 }
 
+TEST_F(StorageCursorTest, SettingPrivate) {
+    EXPECT_EQ(getTableCursorsSize(), 1);
+
+    EXPECT_FALSE(cursor.set(6684));
+    EXPECT_EQ(cursor.current().second, "tanned inmate");
+
+    std::map<uint64_t, std::string>::const_iterator reference = data.begin();
+    std::advance(reference, 5);
+    EXPECT_TRUE(cursor.set(reference->first));
+    EXPECT_EQ(cursor.current().second, reference->second);
+
+    ++reference;
+    cursor.next();
+    EXPECT_EQ(cursor.current().second, reference->second);
+
+    ++reference;
+    cursor.next();
+    EXPECT_EQ(cursor.current().second, reference->second);
+
+    --reference;
+    cursor.prev();
+    EXPECT_EQ(cursor.current().second, reference->second);
+
+    --reference;
+    cursor.prev();
+    EXPECT_EQ(cursor.current().second, reference->second);
+
+    --reference;
+    cursor.prev();
+    EXPECT_EQ(cursor.current().second, reference->second);
+}
+
 TEST_F(StorageCursorTest, Destruction) {
+    EXPECT_EQ(getTableCursorsSize(), 1);
     cursor.close();
+    EXPECT_EQ(getTableCursorsSize(), 1);
 
     EXPECT_THROW(cursor.first(), LMDBAL::CursorNotReady);
     EXPECT_THROW(cursor.last(), LMDBAL::CursorNotReady);
@@ -167,11 +213,14 @@ TEST_F(StorageCursorTest, Destruction) {
     EXPECT_THROW(cursor.current(), LMDBAL::CursorNotReady);
 
     cursor = LMDBAL::Cursor<uint64_t, std::string>();
+    EXPECT_EQ(getTableCursorsSize(), 0);
 
     cursor = table->createCursor();
+    EXPECT_EQ(getTableCursorsSize(), 1);
 }
 
 TEST_F(StorageCursorTest, FirstPublic) {
+    EXPECT_EQ(getTableCursorsSize(), 1);
     transaction = db->beginReadOnlyTransaction();
 
     cursor.open(transaction);
@@ -183,6 +232,7 @@ TEST_F(StorageCursorTest, FirstPublic) {
 }
 
 TEST_F(StorageCursorTest, NextPublic) {
+    EXPECT_EQ(getTableCursorsSize(), 1);
     std::map<uint64_t, std::string>::const_iterator reference = data.begin();
 
     reference++;
@@ -202,6 +252,7 @@ TEST_F(StorageCursorTest, NextPublic) {
 }
 
 TEST_F(StorageCursorTest, LastPublic) {
+    EXPECT_EQ(getTableCursorsSize(), 1);
     std::pair<uint64_t, std::string> element = cursor.last();
     std::map<uint64_t, std::string>::const_reverse_iterator reference = data.rbegin();
 
@@ -210,6 +261,7 @@ TEST_F(StorageCursorTest, LastPublic) {
 }
 
 TEST_F(StorageCursorTest, PrevPublic) {
+    EXPECT_EQ(getTableCursorsSize(), 1);
     std::map<uint64_t, std::string>::const_reverse_iterator reference = data.rbegin();
 
     reference++;
@@ -229,6 +281,7 @@ TEST_F(StorageCursorTest, PrevPublic) {
 }
 
 TEST_F(StorageCursorTest, CurrentPublic) {
+    EXPECT_EQ(getTableCursorsSize(), 1);
     std::pair<uint64_t, std::string> element = cursor.first();
     std::map<uint64_t, std::string>::const_iterator reference = data.begin();
 
@@ -259,7 +312,73 @@ TEST_F(StorageCursorTest, CurrentPublic) {
     EXPECT_EQ(element.second, reference->second);
 }
 
+TEST_F(StorageCursorTest, SettingPublic) {
+    EXPECT_EQ(getTableCursorsSize(), 1);
+
+    EXPECT_FALSE(cursor.set(557));
+    EXPECT_EQ(cursor.current().second, "resilent pick forefront");
+
+    std::map<uint64_t, std::string>::const_iterator reference = data.begin();
+    std::advance(reference, 3);
+    EXPECT_TRUE(cursor.set(reference->first));
+    EXPECT_EQ(cursor.current().second, reference->second);
+
+    ++reference;
+    cursor.next();
+    EXPECT_EQ(cursor.current().second, reference->second);
+
+    ++reference;
+    cursor.next();
+    EXPECT_EQ(cursor.current().second, reference->second);
+
+    --reference;
+    cursor.prev();
+    EXPECT_EQ(cursor.current().second, reference->second);
+
+    --reference;
+    cursor.prev();
+    EXPECT_EQ(cursor.current().second, reference->second);
+
+    --reference;
+    cursor.prev();
+    EXPECT_EQ(cursor.current().second, reference->second);
+}
+
+TEST_F(StorageCursorTest, CursorRAIIBehaviour) {
+    int initialiCursorsAmount = getTableCursorsSize();
+    {
+        LMDBAL::Cursor<uint64_t, std::string> cur = table->createCursor();
+        EXPECT_EQ(initialiCursorsAmount + 1, getTableCursorsSize());
+        cur.open(transaction);
+        EXPECT_NO_THROW(cur.first());
+    }
+
+    EXPECT_EQ(initialiCursorsAmount, getTableCursorsSize());
+    LMDBAL::Cursor<uint64_t, std::string> cur;
+    EXPECT_EQ(initialiCursorsAmount, getTableCursorsSize());
+    EXPECT_EQ(cur.empty(), true);
+    cur = table->createCursor();
+    EXPECT_EQ(cur.empty(), false);
+    EXPECT_EQ(initialiCursorsAmount + 1, getTableCursorsSize());
+    EXPECT_THROW(emptyTable->destroyCursor(cur), LMDBAL::Unknown);
+    table->destroyCursor(cur);
+    EXPECT_EQ(cur.empty(), true);
+    EXPECT_EQ(initialiCursorsAmount, getTableCursorsSize());
+
+    cur = table->createCursor();
+    EXPECT_EQ(initialiCursorsAmount + 1, getTableCursorsSize());
+    EXPECT_EQ(cur.empty(), false);
+
+    cur.drop();
+    EXPECT_EQ(cur.empty(), true);
+    EXPECT_EQ(initialiCursorsAmount, getTableCursorsSize());
+
+    EXPECT_NO_THROW(cur.drop());
+    EXPECT_THROW(table->destroyCursor(cur), LMDBAL::Unknown);
+}
+
 TEST_F(StorageCursorTest, CornerCases) {
+    EXPECT_EQ(getTableCursorsSize(), 1);
     transaction.terminate();
     EXPECT_THROW(cursor.current(), LMDBAL::Unknown);
     cursor.close();