Adjusted the way that Wrapping records works to clean up interfaces

1 files changed, 25 insertions, 33 deletions

diff --git a/tests/mutable_buffer_tests.cpp b/tests/mutable_buffer_tests.cpp
index fc8b511..bb8e2c2 100644
--- a/tests/mutable_buffer_tests.cpp
+++ b/tests/mutable_buffer_tests.cpp
@@ -25,7 +25,7 @@ using namespace de;
 
 START_TEST(t_create)
 {
-    auto buffer = new MutableBuffer<WrappedRec>(100, true, 50);
+    auto buffer = new MutableBuffer<Rec>(100, true, 50);
 
     ck_assert_ptr_nonnull(buffer);
     ck_assert_int_eq(buffer->get_capacity(), 100);
@@ -42,12 +42,12 @@ END_TEST
 
 START_TEST(t_insert)
 {
-    auto buffer = new MutableBuffer<WrappedWRec>(100, true, 50);
+    auto buffer = new MutableBuffer<WRec>(100, true, 50);
 
     uint64_t key = 0;
     uint32_t val = 5;
 
-    WrappedWRec rec = {0, 5, 1};
+    WRec rec = {0, 5, 1};
 
     for (size_t i=0; i<99; i++) {
         ck_assert_int_eq(buffer->append(rec), 1);
@@ -77,11 +77,11 @@ END_TEST
 
 START_TEST(t_insert_tombstones)
 {
-    auto buffer = new MutableBuffer<WrappedRec>(100, true, 50);
+    auto buffer = new MutableBuffer<Rec>(100, true, 50);
 
     size_t ts_cnt = 0;
 
-    WrappedRec rec = {0, 5};
+    Rec rec = {0, 5};
 
     for (size_t i=0; i<99; i++) {
         bool ts = false;
@@ -90,9 +90,7 @@ START_TEST(t_insert_tombstones)
             ts=true;
         }
 
-        rec.set_tombstone(ts);
-
-        ck_assert_int_eq(buffer->append(rec), 1);
+        ck_assert_int_eq(buffer->append(rec, ts), 1);
         ck_assert_int_eq(buffer->check_tombstone(rec), ts);
 
         rec.key++;
@@ -104,11 +102,9 @@ START_TEST(t_insert_tombstones)
     }
 
     // inserting one more tombstone should not be possible
-    rec.set_tombstone();
-    ck_assert_int_eq(buffer->append(rec), 0);
+    ck_assert_int_eq(buffer->append(rec, true), 0);
 
 
-    rec.set_tombstone(false);
     ck_assert_int_eq(buffer->append(rec), 1);
 
     rec.key++;
@@ -124,10 +120,10 @@ END_TEST
 
 START_TEST(t_truncate)
 {
-    auto buffer = new MutableBuffer<WrappedRec>(100, true, 100);
+    auto buffer = new MutableBuffer<Rec>(100, true, 100);
 
     size_t ts_cnt = 0;
-    WrappedRec rec = {0, 5};
+    Rec rec = {0, 5};
 
     for (size_t i=0; i<100; i++) {
         bool ts = false;
@@ -136,9 +132,7 @@ START_TEST(t_truncate)
             ts=true;
         }
 
-        rec.set_tombstone(ts);
-
-        ck_assert_int_eq(buffer->append(rec), 1);
+        ck_assert_int_eq(buffer->append(rec, ts), 1);
         ck_assert_int_eq(buffer->check_tombstone(rec), ts);
 
         rec.key++;
@@ -149,7 +143,6 @@ START_TEST(t_truncate)
     }
 
     ck_assert_int_eq(buffer->is_full(), 1);
-    rec.set_tombstone(false);
     ck_assert_int_eq(buffer->append(rec), 0);
 
     ck_assert_int_eq(buffer->truncate(), 1);
@@ -165,11 +158,11 @@ START_TEST(t_truncate)
 END_TEST
 
 
-START_TEST(t_sorted_output)
+START_TEST(t_get_data)
 {
     size_t cnt = 100;
 
-    auto buffer = new MutableBuffer<WrappedRec>(cnt, true, cnt/2);
+    auto buffer = new MutableBuffer<Rec>(cnt, true, cnt/2);
 
 
     std::vector<uint64_t> keys(cnt);
@@ -184,23 +177,22 @@ START_TEST(t_sorted_output)
 
     uint32_t val = 12345;
     for (size_t i=0; i<cnt-2; i++) {
-        buffer->append(WrappedRec {keys[i], val});
+        buffer->append(Rec {keys[i], val});
     }
 
-    WrappedRec r1 = {keys[cnt-2], val};
-    r1.set_tombstone();
-    buffer->append(r1);
+    Rec r1 = {keys[cnt-2], val};
+    buffer->append(r1, true);
 
-    WrappedRec r2 = {keys[cnt-1], val};
-    r2.set_tombstone();
-    buffer->append(r2);
+    Rec r2 = {keys[cnt-1], val};
+    buffer->append(r2, true);
 
 
     auto *sorted_records = buffer->get_data();
     std::sort(keys.begin(), keys.end());
+    std::sort(sorted_records, sorted_records + buffer->get_record_count(), std::less<Wrapped<Rec>>());
 
     for (size_t i=0; i<cnt; i++) {
-        ck_assert_int_eq(sorted_records[i].key, keys[i]);
+        ck_assert_int_eq(sorted_records[i].rec.key, keys[i]);
     }
 
     delete buffer;
@@ -208,7 +200,7 @@ START_TEST(t_sorted_output)
 END_TEST
 
 
-void insert_records(std::vector<std::pair<uint64_t, uint32_t>> *values, size_t start, size_t stop, MutableBuffer<WrappedRec> *buffer)
+void insert_records(std::vector<std::pair<uint64_t, uint32_t>> *values, size_t start, size_t stop, MutableBuffer<Rec> *buffer)
 {
     for (size_t i=start; i<stop; i++) {
         buffer->append({(*values)[i].first, (*values)[i].second});
@@ -220,11 +212,11 @@ void insert_records(std::vector<std::pair<uint64_t, uint32_t>> *values, size_t s
 START_TEST(t_multithreaded_insert)
 {
     size_t cnt = 10000;
-    auto buffer = new MutableBuffer<WrappedRec>(cnt, true, cnt/2);
+    auto buffer = new MutableBuffer<Rec>(cnt, true, cnt/2);
 
-    std::vector<WrappedRec> records(cnt);
+    std::vector<Rec> records(cnt);
     for (size_t i=0; i<cnt; i++) {
-        records[i] = WrappedRec {(uint64_t) rand(), (uint32_t) rand()};
+        records[i] = Rec {(uint64_t) rand(), (uint32_t) rand()};
     }
 
     // perform a t_multithreaded insertion
@@ -285,8 +277,8 @@ Suite *unit_testing()
     suite_add_tcase(unit, truncate);
 
 
-    TCase *sorted_out = tcase_create("de::MutableBuffer::sorted_output");
-    tcase_add_test(sorted_out, t_sorted_output);
+    TCase *sorted_out = tcase_create("de::MutableBuffer::get_data");
+    tcase_add_test(sorted_out, t_get_data);
 
     suite_add_tcase(unit, sorted_out);