Adjusted query result interfacesHEADmaster

Now, the vector<> is part of the user-defined type, not required by the
framework. This should allow for more flexibility in either using
alternative containers, or for more sensible implementations of queries
with single value results (like range count).

8 files changed, 246 insertions, 226 deletions

diff --git a/tests/include/irs.h b/tests/include/irs.h
index 1c5be2c..35a4bbb 100644
--- a/tests/include/irs.h
+++ b/tests/include/irs.h
@@ -18,7 +18,6 @@
 #pragma once
 
 #include "query/irs.h"
-#include <algorithm>
 
 /*
  * Uncomment these lines temporarily to remove errors in this file
@@ -27,16 +26,16 @@
  * should be included in the source file that includes this one, above the
  * include statement.
  */
-#include "shard/ISAMTree.h"
-#include "query/irs.h"
-#include "testing.h"
-#include <check.h>
-#include <gsl/gsl_rng.h>
-using namespace de;
+// #include "shard/ISAMTree.h"
+// #include "query/irs.h"
+// #include "testing.h"
+// #include <check.h>
+// #include <gsl/gsl_rng.h>
+// using namespace de;
 
-typedef Rec R;
-typedef ISAMTree<R> Shard;
-typedef irs::Query<ISAMTree<R>> Query;
+// typedef Rec R;
+// typedef ISAMTree<R> Shard;
+// typedef irs::Query<ISAMTree<R>> Query;
 
 static gsl_rng *g_rng;
 
@@ -60,8 +59,8 @@ START_TEST(t_irs)
 
     ck_assert_int_eq(result.size(), k);
     for (size_t i=0; i<result.size(); i++) {
-        ck_assert_int_le(result[i].rec.key, parms.upper_bound);
-        ck_assert_int_ge(result[i].rec.key, parms.lower_bound);
+        ck_assert_int_le(result[i].key, parms.upper_bound);
+        ck_assert_int_ge(result[i].key, parms.lower_bound);
     }
 
     delete buffer;
@@ -89,8 +88,8 @@ START_TEST(t_buffer_irs)
 
         ck_assert_int_le(result.size(), k);
         for (size_t i=0; i<result.size(); i++) {
-            ck_assert_int_le(result[i].rec.key, parms.upper_bound);
-            ck_assert_int_ge(result[i].rec.key, parms.lower_bound);
+            ck_assert_int_le(result[i].key, parms.upper_bound);
+            ck_assert_int_ge(result[i].key, parms.lower_bound);
         }
     }
 
@@ -128,7 +127,7 @@ START_TEST(t_irs_merge)
 
     irs::Query<Shard>::distribute_query(&parms, {query1, query2}, &dummy_buffer_query);
 
-    std::vector<std::vector<irs::Query<Shard>::LocalResultType>> results(2);
+    std::vector<irs::Query<Shard>::LocalResultType> results(2);
     results[0] = irs::Query<Shard>::local_query(&shard1, query1);     
     results[1] = irs::Query<Shard>::local_query(&shard2, query2); 
     delete query1;
@@ -136,16 +135,16 @@ START_TEST(t_irs_merge)
 
     ck_assert_int_eq(results[0].size() + results[1].size(), k);
 
-    std::vector<std::vector<Wrapped<R>>> proc_results;
+    std::vector<std::vector<R>> proc_results;
 
     for (size_t j=0; j<results.size(); j++) {
-        proc_results.emplace_back(std::vector<Wrapped<R>>());
+        proc_results.emplace_back(std::vector<R>());
         for (size_t i=0; i<results[j].size(); i++) {
             proc_results[j].emplace_back(results[j][i]);
         }
     }
 
-    std::vector<irs::Query<Shard>::ResultType> result;
+    irs::Query<Shard>::ResultType result;
     irs::Query<Shard>::combine(proc_results, nullptr, result);
     ck_assert_int_eq(result.size(), k);
 
@@ -154,7 +153,7 @@ START_TEST(t_irs_merge)
 }
 END_TEST
 
-static void inject_irs_tests(Suite *suite) {
+[[maybe_unused]] static void inject_irs_tests(Suite *suite) {
     g_rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     TCase *irs = tcase_create("Independent Range Sampling Query Testing"); 
diff --git a/tests/include/pointlookup.h b/tests/include/pointlookup.h
index af58440..f3a03dd 100644
--- a/tests/include/pointlookup.h
+++ b/tests/include/pointlookup.h
@@ -27,12 +27,12 @@
  * include statement.
  */
 
-#include "shard/FSTrie.h"
-#include "testing.h"
-#include <check.h>
-using namespace de;
-typedef StringRec R;
-typedef FSTrie<R> Shard;
+// #include "shard/FSTrie.h"
+// #include "testing.h"
+// #include <check.h>
+// using namespace de;
+// typedef StringRec R;
+// typedef FSTrie<R> Shard;
 
 START_TEST(t_point_lookup_query)
 {
@@ -99,7 +99,7 @@ START_TEST(t_buffer_point_lookup)
 END_TEST
 
 
-static void inject_pointlookup_tests(Suite *suite) {
+[[maybe_unused]] static void inject_pointlookup_tests(Suite *suite) {
     TCase *point_lookup_query = tcase_create("Point Lookup Testing"); 
     tcase_add_test(point_lookup_query, t_point_lookup_query); 
     tcase_add_test(point_lookup_query, t_buffer_point_lookup); 
diff --git a/tests/include/rangecount.h b/tests/include/rangecount.h
index 22189b9..b77c77d 100644
--- a/tests/include/rangecount.h
+++ b/tests/include/rangecount.h
@@ -18,7 +18,6 @@
 #pragma once
 
 #include "query/rangecount.h"
-#include <algorithm>
 
 /*
  * Uncomment these lines temporarily to remove errors in this file
@@ -28,7 +27,6 @@
  * include statement.
  */
 // #include "shard/ISAMTree.h"
-// #include "query/rangequery.h"
 // #include "testing.h"
 // #include <check.h>
 // using namespace de;
@@ -49,7 +47,7 @@ START_TEST(t_range_count)
     auto result = rc::Query<Shard>::local_query(&shard, local_query);
     delete local_query;
 
-    ck_assert_int_eq(result[0].record_count - result[0].tombstone_count, parms.upper_bound - parms.lower_bound + 1);
+    ck_assert_int_eq(result.record_count - result.tombstone_count, parms.upper_bound - parms.lower_bound + 1);
 
     delete buffer;
 }
@@ -68,7 +66,7 @@ START_TEST(t_buffer_range_count)
         auto result = rc::Query<Shard>::local_query_buffer(query); 
         delete query;
 
-        ck_assert_int_eq(result[0].record_count - result[0].tombstone_count, parms.upper_bound - parms.lower_bound + 1);
+        ck_assert_int_eq(result.record_count - result.tombstone_count, parms.upper_bound - parms.lower_bound + 1);
     }
 
     delete buffer;
@@ -91,28 +89,28 @@ START_TEST(t_range_count_merge)
     auto query1 = rc::Query<Shard>::local_preproc(&shard1, &parms);
     auto query2 = rc::Query<Shard>::local_preproc(&shard2, &parms);
 
-    std::vector<std::vector<rc::Query<Shard>::LocalResultType>> results(2);
+    std::vector<rc::Query<Shard>::LocalResultType> results(2);
     results[0] = rc::Query<Shard>::local_query(&shard1, query1);     
     results[1] = rc::Query<Shard>::local_query(&shard2, query2); 
     delete query1;
     delete query2;
 
-    size_t reccnt = results[0][0].record_count + results[1][0].record_count;
-    size_t tscnt = results[0][0].tombstone_count + results[1][0].tombstone_count;
+    size_t reccnt = results[0].record_count + results[1].record_count;
+    size_t tscnt = results[0].tombstone_count + results[1].tombstone_count;
 
     ck_assert_int_eq(reccnt - tscnt, result_size);
 
-    std::vector<rc::Query<Shard>::ResultType> result;
+    rc::Query<Shard>::ResultType result;
     rc::Query<Shard>::combine(results, nullptr, result);
 
-    ck_assert_int_eq(result[0], result_size);
+    ck_assert_int_eq(result, result_size);
 
     delete buffer1;
     delete buffer2;
 }
 END_TEST
 
-static void inject_rangecount_tests(Suite *suite) {
+[[maybe_unused]] static void inject_rangecount_tests(Suite *suite) {
     TCase *range_count = tcase_create("Range Query Testing"); 
     tcase_add_test(range_count, t_range_count); 
     tcase_add_test(range_count, t_buffer_range_count); 
diff --git a/tests/include/rangequery.h b/tests/include/rangequery.h
index 5c3c1d6..f7bb7c1 100644
--- a/tests/include/rangequery.h
+++ b/tests/include/rangequery.h
@@ -99,7 +99,7 @@ START_TEST(t_range_query_merge)
     auto query1 = rq::Query<Shard>::local_preproc(&shard1, &parms);
     auto query2 = rq::Query<Shard>::local_preproc(&shard2, &parms);
 
-    std::vector<std::vector<rq::Query<Shard>::LocalResultType>> results(2);
+    std::vector<rq::Query<Shard>::LocalResultType> results(2);
     results[0] = rq::Query<Shard>::local_query(&shard1, query1);     
     results[1] = rq::Query<Shard>::local_query(&shard2, query2); 
     delete query1;
@@ -116,7 +116,7 @@ START_TEST(t_range_query_merge)
         }
     }
 
-    std::vector<rq::Query<Shard>::ResultType> result;
+    rq::Query<Shard>::ResultType result;
     rq::Query<Shard>::combine(proc_results, nullptr, result);
     std::sort(result.begin(), result.end());
 
@@ -134,41 +134,7 @@ START_TEST(t_range_query_merge)
 }
 END_TEST
 
-
-START_TEST(t_lower_bound)
-{
-    auto buffer1 = create_sequential_mbuffer<R>(100, 200);
-    auto buffer2 = create_sequential_mbuffer<R>(400, 1000);
-
-    auto shard1 = new Shard(buffer1->get_buffer_view());
-    auto shard2 = new Shard(buffer2->get_buffer_view());
-
-    std::vector<Shard*> shards = {shard1, shard2};
-
-    auto merged = Shard(shards);
-
-    for (uint32_t i=100; i<1000; i++) {
-        auto idx = merged.get_lower_bound(i);
-
-        assert(idx < merged.get_record_count());
-
-        auto res = merged.get_record_at(idx);
-
-        if (i >=200 && i <400) {
-            ck_assert_int_lt(res->rec.key, i);
-        } else {
-            ck_assert_int_eq(res->rec.key, i);
-        }
-    }
-
-    delete buffer1;
-    delete buffer2;
-    delete shard1;
-    delete shard2;
-}
-END_TEST
-
-static void inject_rangequery_tests(Suite *suite) {
+[[maybe_unused]] static void inject_rangequery_tests(Suite *suite) {
     TCase *range_query = tcase_create("Range Query Testing"); 
     tcase_add_test(range_query, t_range_query); 
     tcase_add_test(range_query, t_buffer_range_query); 
diff --git a/tests/include/shard_standard.h b/tests/include/shard_standard.h
index ece2a57..de43edc 100644
--- a/tests/include/shard_standard.h
+++ b/tests/include/shard_standard.h
@@ -35,19 +35,27 @@ typedef ISAMTree<R> Shard;
 START_TEST(t_mbuffer_init)
 {
     auto buffer = new MutableBuffer<R>(512, 1024);
+    R r = {};
+    
     for (uint64_t i = 512; i > 0; i--) {
         uint32_t v = i;
-        buffer->append({i, v});
+        r.key = i;
+        r.value = v;
+        buffer->append(r);
     }
     
     for (uint64_t i = 1; i <= 256; ++i) {
         uint32_t v = i;
-        buffer->append({i, v}, true);
+        r.key = i;
+        r.value = v;
+        buffer->append(r, true);
     }
 
     for (uint64_t i = 257; i <= 512; ++i) {
         uint32_t v = i + 1;
-        buffer->append({i, v});
+        r.key = i;
+        r.value = v;
+        buffer->append(r);
     }
 
     Shard* shard = new Shard(buffer->get_buffer_view());
diff --git a/tests/include/testing.h b/tests/include/testing.h
index 33cbb3f..090221c 100644
--- a/tests/include/testing.h
+++ b/tests/include/testing.h
@@ -3,7 +3,7 @@
  *
  * Unit test utility functions/definitions
  *
- * Copyright (C) 2023 Douglas Rumbaugh <drumbaugh@psu.edu> 
+ * Copyright (C) 2023 Douglas Rumbaugh <drumbaugh@psu.edu>
  *                    Dong Xie <dongx@psu.edu>
  *
  * Distributed under the Modified BSD License.
@@ -13,160 +13,184 @@
 
 #include <string>
 
-#include <unistd.h>
 #include <fcntl.h>
 #include <fstream>
 #include <sstream>
+#include <unistd.h>
 
-#include "util/types.h"
-#include "psu-util/alignment.h"
-#include "framework/structure/MutableBuffer.h"
 #include "framework/interface/Record.h"
+#include "framework/structure/MutableBuffer.h"
+#include "psu-util/alignment.h"
+#include "util/types.h"
 
 typedef de::WeightedRecord<uint64_t, uint32_t, uint64_t> WRec;
 typedef de::Record<uint64_t, uint32_t> Rec;
 typedef de::EuclidPoint<uint64_t> PRec;
 
-typedef de::Record<const char*, uint64_t> StringRec;
+typedef de::Record<const char *, uint64_t> StringRec;
 
 static std::string kjv_wordlist = "tests/data/kjv-wordlist.txt";
 static std::string summa_wordlist = "tests/data/summa-wordlist.txt";
 
-static std::vector<std::unique_ptr<char[]>> string_data;
+static struct sd {
+  std::vector<char *> data;
+  ~sd() {
+    for (size_t i = 0; i < data.size(); i++) {
+      delete data[i];
+    }
+  }
+} string_data;
 
-[[maybe_unused]] static std::vector<StringRec> read_string_data(std::string fname, size_t n) {
-    std::vector<StringRec> vec;
-    vec.reserve(n);
-    string_data.reserve(n);
+[[maybe_unused]] static std::vector<StringRec>
+read_string_data(std::string fname, size_t n) {
+  std::vector<StringRec> vec;
+  vec.reserve(n);
+  string_data.data.reserve(n);
 
-    std::fstream file;
-    file.open(fname, std::ios::in);
+  std::fstream file;
+  file.open(fname, std::ios::in);
 
-    for (size_t i=0; i<n; i++) {
-        std::string line;
-        if (!std::getline(file, line, '\n')) break;
+  for (size_t i = 0; i < n; i++) {
+    std::string line;
+    if (!std::getline(file, line, '\n'))
+      break;
 
-        std::stringstream ls(line);
-        std::string field;
+    std::stringstream ls(line);
+    std::string field;
 
-        std::getline(ls, field, '\t');
-        uint64_t val = atol(field.c_str());
-        std::getline(ls, field, '\n');
+    std::getline(ls, field, '\t');
+    uint64_t val = atol(field.c_str());
+    std::getline(ls, field, '\n');
 
-        char *c = strdup(field.c_str());
+    string_data.data.push_back(strdup(field.c_str()));
 
-        string_data.push_back(std::unique_ptr<char[]>(c));
+    StringRec r{string_data.data[string_data.data.size() - 1], val,
+                field.size()};
 
-        StringRec r{string_data[string_data.size() -1].get(), val, field.size()};
-        
-        vec.push_back(r);
-    }
+    vec.push_back(r);
+  }
 
-    return vec;
+  return vec;
 }
 
-
-template <de::RecordInterface R> 
+template <de::RecordInterface R>
 std::vector<R> strip_wrapping(std::vector<de::Wrapped<R>> vec) {
-    std::vector<R> out(vec.size());
-    for (uint32_t i=0; i<vec.size(); i++) {
-        out[i] = vec[i].rec;
-    }
+  std::vector<R> out(vec.size());
+  for (uint32_t i = 0; i < vec.size(); i++) {
+    out[i] = vec[i].rec;
+  }
 
-    return out;
+  return out;
 }
 
-[[maybe_unused]] static bool initialize_test_file(std::string fname, size_t page_cnt)
-{
-    auto flags = O_RDWR | O_CREAT | O_TRUNC;
-    mode_t mode = 0640;
-    char *page = nullptr;
-
-    int fd = open(fname.c_str(), flags, mode);
-    if (fd == -1) {
-        goto error;
+[[maybe_unused]] static bool initialize_test_file(std::string fname,
+                                                  size_t page_cnt) {
+  auto flags = O_RDWR | O_CREAT | O_TRUNC;
+  mode_t mode = 0640;
+  char *page = nullptr;
+
+  int fd = open(fname.c_str(), flags, mode);
+  if (fd == -1) {
+    goto error;
+  }
+
+  page = (char *)aligned_alloc(psudb::SECTOR_SIZE, psudb::PAGE_SIZE);
+  if (!page) {
+    goto error_opened;
+  }
+
+  for (size_t i = 0; i <= page_cnt; i++) {
+    *((int *)page) = i;
+    if (write(fd, page, psudb::PAGE_SIZE) == -1) {
+      goto error_alloced;
     }
+  }
 
-    page = (char *) aligned_alloc(psudb::SECTOR_SIZE, psudb::PAGE_SIZE);
-    if (!page) {
-        goto error_opened;
-    }
+  free(page);
 
-    for (size_t i=0; i<=page_cnt; i++) {
-        *((int *) page) = i;
-        if (write(fd, page, psudb::PAGE_SIZE) == -1) {
-            goto error_alloced;
-        }
-    }
-
-    free(page);
-
-    return 1;
+  return 1;
 
 error_alloced:
-    free(page);
+  free(page);
 
 error_opened:
-    close(fd);
+  close(fd);
 
 error:
-    return 0;
+  return 0;
 }
 
-[[maybe_unused]] static bool roughly_equal(int n1, int n2, size_t mag, double epsilon) {
-    return ((double) std::abs(n1 - n2) / (double) mag) < epsilon;
+[[maybe_unused]] static bool roughly_equal(int n1, int n2, size_t mag,
+                                           double epsilon) {
+  return ((double)std::abs(n1 - n2) / (double)mag) < epsilon;
 }
 
 template <de::RecordInterface R>
-static de::MutableBuffer<R> *create_test_mbuffer(size_t cnt)
-{
-    auto buffer = new de::MutableBuffer<R>(cnt/2, cnt);
-
-    if constexpr (de::KVPInterface<R>){
-        if constexpr (std::is_same_v<decltype(R::key), const char*>){
-            auto records = read_string_data(kjv_wordlist, cnt);
-            for (size_t i=0; i<cnt; i++) {
-                buffer->append(records[i]);
-            }
+static de::MutableBuffer<R> *create_test_mbuffer(size_t cnt) {
+  auto buffer = new de::MutableBuffer<R>(cnt / 2, cnt);
+  R r = {};
+
+  if constexpr (de::KVPInterface<R>) {
+    if constexpr (std::is_same_v<decltype(R::key), const char *>) {
+      auto records = read_string_data(kjv_wordlist, cnt);
+      for (size_t i = 0; i < cnt; i++) {
+        buffer->append(records[i]);
+      }
+    } else {
+      for (size_t i = 0; i < cnt; i++) {
+        r.key = rand();
+        r.value = rand();
+        if constexpr (de::WeightedRecordInterface<R>) {
+          r.weight = 1;
+          buffer->append(r);
         } else {
-            for (size_t i = 0; i < cnt; i++) {
-                if constexpr (de::WeightedRecordInterface<R>) {
-                    buffer->append({(uint64_t) rand(), (uint32_t) rand(), 1});
-                } else {
-                    buffer->append({(uint64_t) rand(), (uint32_t) rand()});
-                }
-            }
-        }
-    } else if constexpr (de::NDRecordInterface<R>) {
-        for (size_t i=0; i<cnt; i++) {
-            buffer->append({(uint64_t) rand(), (uint64_t) rand()});
+          buffer->append(r);
         }
-    } 
+      }
+    }
+  } else if constexpr (de::NDRecordInterface<R>) {
+    for (size_t i = 0; i < cnt; i++) {
+      r.data[0] = rand();
+      r.data[1] = rand();
+      buffer->append(r);
+    }
+  }
 
-    return buffer;
+  return buffer;
 }
 
 template <de::RecordInterface R>
-static de::MutableBuffer<R> *create_sequential_mbuffer(size_t start, size_t stop)
-{
-    size_t cnt = stop - start;
-    auto buffer = new de::MutableBuffer<R>(cnt/2, cnt);
-
-    for (uint32_t i=start; i<stop; i++) {
-
-        if constexpr (de::WeightedRecordInterface<R>) {
-            buffer->append({i, i, 1});
-        } else {
-            buffer->append({i, i});
-        }
+static de::MutableBuffer<R> *create_sequential_mbuffer(size_t start,
+                                                       size_t stop) {
+  size_t cnt = stop - start;
+  auto buffer = new de::MutableBuffer<R>(cnt / 2, cnt);
+
+  R r = {};
+
+  for (uint32_t i = start; i < stop; i++) {
+    if constexpr (de::NDRecordInterface<R>) {
+        r.data[0] = i;
+        r.data[1] = i;
+        buffer->append(r);
+    } else {
+      r.key = i;
+      r.value = i;
+      if constexpr (de::WeightedRecordInterface<R>) {
+        r.weight = 1;
+        buffer->append(r);
+      } else {
+        buffer->append(r);
+      }
     }
+  }
 
-    return buffer;
+  return buffer;
 }
 
 /*
 template <de::KVPInterface R>
-static de::MutableBuffer<R> *create_test_mbuffer_tombstones(size_t cnt, size_t ts_cnt) 
+static de::MutableBuffer<R> *create_test_mbuffer_tombstones(size_t cnt, size_t
+ts_cnt)
 {
     auto buffer = new de::MutableBuffer<R>(cnt/2, cnt);
 
@@ -198,43 +222,55 @@ static de::MutableBuffer<R> *create_test_mbuffer_tombstones(size_t cnt, size_t t
 */
 
 template <typename R>
-requires de::WeightedRecordInterface<R> && de::KVPInterface<R>
-static de::MutableBuffer<R> *create_weighted_mbuffer(size_t cnt)
-{
-    auto buffer = new de::MutableBuffer<R>(cnt/2, cnt);
-    
-    // Put in half of the count with weight one.
-    for (uint32_t i=0; i< cnt / 2; i++) {
-        buffer->append(R {1, i, 2});
-    }
-
-    // put in a quarter of the count with weight four.
-    for (uint32_t i=0; i< cnt / 4; i++) {
-        buffer->append(R {2, i, 4});
-    }
-
-    // the remaining quarter with weight eight.
-    for (uint32_t i=0; i< cnt / 4; i++) {
-        buffer->append(R {3, i, 8});
-    }
-
-    return buffer;
+  requires de::WeightedRecordInterface<R> && de::KVPInterface<R>
+static de::MutableBuffer<R> *create_weighted_mbuffer(size_t cnt) {
+  auto buffer = new de::MutableBuffer<R>(cnt / 2, cnt);
+  R r = {};
+
+  // Put in half of the count with weight one.
+  for (uint32_t i = 0; i < cnt / 2; i++) {
+    r.key = 1;
+    r.value = i;
+    r.weight = 2;
+    buffer->append(r);
+  }
+
+  // put in a quarter of the count with weight four.
+  for (uint32_t i = 0; i < cnt / 4; i++) {
+    r.key = 2;
+    r.value = i;
+    r.weight = 4;
+    buffer->append(r);
+  }
+
+  // the remaining quarter with weight eight.
+  for (uint32_t i = 0; i < cnt / 4; i++) {
+    r.key = 3;
+    r.value = i;
+    r.weight = 8;
+    buffer->append(r);
+  }
+
+  return buffer;
 }
 
 template <de::KVPInterface R>
-static de::MutableBuffer<R> *create_double_seq_mbuffer(size_t cnt, bool ts=false) 
-{
-    auto buffer = new de::MutableBuffer<R>(cnt/2, cnt);
-
-    for (uint32_t i = 0; i < cnt / 2; i++) { 
-        buffer->append({i, i}, ts);
-    }
-
-    for (uint32_t i = 0; i < cnt / 2; i++) {
-        buffer->append({i, i+1}, ts);
-    }
-
-    return buffer;
+static de::MutableBuffer<R> *create_double_seq_mbuffer(size_t cnt,
+                                                       bool ts = false) {
+  auto buffer = new de::MutableBuffer<R>(cnt / 2, cnt);
+  R r = {};
+
+  for (uint32_t i = 0; i < cnt / 2; i++) {
+    r.key = i;
+    r.value = i;
+    buffer->append(r, ts);
+  }
+
+  for (uint32_t i = 0; i < cnt / 2; i++) {
+    r.key = i;
+    r.value = i + 1;
+    buffer->append(r, ts);
+  }
+
+  return buffer;
 }
-
-
diff --git a/tests/mutable_buffer_tests.cpp b/tests/mutable_buffer_tests.cpp
index c3e1b34..16f9269 100644
--- a/tests/mutable_buffer_tests.cpp
+++ b/tests/mutable_buffer_tests.cpp
@@ -52,7 +52,9 @@ START_TEST(t_insert)
 {
     auto buffer = new MutableBuffer<Rec>(50, 100);
 
-    Rec rec = {0, 5};
+    Rec rec = {};
+    rec.key = 0;
+    rec.value = 5;
 
     /* insert records up to the low watermark */
     size_t cnt = 0;
@@ -107,7 +109,10 @@ START_TEST(t_advance_head)
 
     /* insert 75 records and get tail when LWM is exceeded */
     size_t new_head = 0;
-    Rec rec = {1, 1};
+    Rec rec = {};
+    rec.key = 1;
+    rec.value = 1;
+
     size_t cnt = 0;
     for (size_t i=0; i<75; i++) {
         ck_assert_int_eq(buffer->append(rec), 1);
@@ -204,7 +209,9 @@ START_TEST(t_truncate)
     auto buffer = new MutableBuffer<Rec>(50, 100);
 
     size_t ts_cnt = 0;
-    Rec rec = {0, 5};
+    Rec rec = {};
+    rec.key = 0;
+    rec.value = 5;
 
     for (size_t i=0; i<100; i++) {
         bool ts = false;
@@ -244,7 +251,10 @@ START_TEST(t_bview_get)
 
     /* insert 75 records and get tail when LWM is exceeded */
     size_t new_head = 0;
-    Rec rec = {1, 1};
+    Rec rec = {};
+    rec.key = 1;
+    rec.value = 1;
+
     size_t cnt = 0;
     for (size_t i=0; i<75; i++) {
         ck_assert_int_eq(buffer->append(rec), 1);
@@ -322,7 +332,10 @@ START_TEST(t_bview_delete)
 
     /* insert 75 records and get tail when LWM is exceeded */
     size_t new_head = 0;
-    Rec rec = {1, 1};
+    Rec rec = {};
+    rec.key = 1;
+    rec.value = 1;
+
     for (size_t i=0; i<75; i++) {
         ck_assert_int_eq(buffer->append(rec), 1);
 
diff --git a/tests/vptree_tests.cpp b/tests/vptree_tests.cpp
index 7e9e79e..53bb526 100644
--- a/tests/vptree_tests.cpp
+++ b/tests/vptree_tests.cpp
@@ -29,8 +29,8 @@ START_TEST(t_mbuffer_init)
     size_t n= 24;
     auto buffer = new MutableBuffer<PRec>(n/2, n);
 
-    for (int64_t i=0; i<n; i++) {
-        buffer->append({(uint64_t) i, (uint64_t) i});
+    for (size_t i=0; i<n; i++) {
+        buffer->append({i, i});
     }
 
     Shard* shard = new Shard(buffer->get_buffer_view());
@@ -139,7 +139,7 @@ START_TEST(t_buffer_query)
         std::sort(result.begin(), result.end());
         size_t start = 120 - 5;
         for (size_t i=0; i<result.size(); i++) {
-            ck_assert_int_eq(result[i].rec.data[0], start++);
+            ck_assert_int_eq(result[i]->rec.data[0], start++);
         }
     }
 
@@ -169,17 +169,17 @@ START_TEST(t_knn_query)
         std::sort(results.begin(), results.end());
 
         if ((int64_t) (p.point.data[0] - p.k/2 - 1) < 0) {
-            ck_assert_int_eq(results[0].rec.data[0], 0);
+            ck_assert_int_eq(results[0]->rec.data[0], 0);
         } else {
-            ck_assert(results[0].rec.data[0] == (p.point.data[0] - p.k/2 - 1) ||
-                      results[0].rec.data[0] == (p.point.data[0] - p.k/2) ||
-                      results[0].rec.data[0] == (p.point.data[0] - p.k/2 + 1));
+            ck_assert(results[0]->rec.data[0] == (p.point.data[0] - p.k/2 - 1) ||
+                      results[0]->rec.data[0] == (p.point.data[0] - p.k/2) ||
+                      results[0]->rec.data[0] == (p.point.data[0] - p.k/2 + 1));
         }
 
 
-        size_t start = results[0].rec.data[0];
+        size_t start = results[0]->rec.data[0];
         for (size_t i=0; i<results.size(); i++) {
-            ck_assert_int_eq(results[i].rec.data[0], start++);
+            ck_assert_int_eq(results[i]->rec.data[0], start++);
         }
     }