Cleaned up shard files (except VPTree)

Cleaned up shard implementations, fixed a few bugs, and set up some
tests. There's still some work to be done in creating tests for the
weighted sampling operations for the alias and aug btree shards.

7 files changed, 437 insertions, 107 deletions

diff --git a/tests/include/concurrent_extension.h b/tests/include/concurrent_extension.h
index 24cb2ce..0993fac 100644
--- a/tests/include/concurrent_extension.h
+++ b/tests/include/concurrent_extension.h
@@ -8,8 +8,8 @@
  * Distributed under the Modified BSD License.
  *
  * WARNING: This file must be included in the main unit test set
- *          after the definition of an appropriate Shard, Query, and Rec
- *          type. In particular, Rec needs to implement the key-value
+ *          after the definition of an appropriate Shard, Query, and R
+ *          type. In particular, R needs to implement the key-value
  *          pair interface. For other types of record, you'll need to
  *          use a different set of unit tests.
  */
@@ -30,7 +30,7 @@
 #include <check.h>
 
 //using namespace de;
-//typedef DynamicExtension<Rec, ISAMTree<Rec>, rq::Query<ISAMTree<Rec>, Rec>, LayoutPolicy::LEVELING, DeletePolicy::TOMBSTONE, FIFOScheduler> DE;
+//typedef DynamicExtension<R, ISAMTree<R>, rq::Query<ISAMTree<R>, R>, LayoutPolicy::LEVELING, DeletePolicy::TOMBSTONE, FIFOScheduler> DE;
 */
 
 
@@ -54,7 +54,7 @@ START_TEST(t_insert)
     uint64_t key = 0;
     uint32_t val = 0;
     for (size_t i=0; i<100; i++) {
-        Rec r = {key, val};
+        R r = {key, val};
         ck_assert_int_eq(test_de->insert(r), 1);
         key++;
         val++;
@@ -75,7 +75,7 @@ START_TEST(t_debug_insert)
     uint64_t key = 0;
     uint32_t val = 0;
     for (size_t i=0; i<1000; i++) {
-        Rec r = {key, val};
+        R r = {key, val};
         ck_assert_int_eq(test_de->insert(r), 1);
         ck_assert_int_eq(test_de->get_record_count(), i+1);
         key++;
@@ -94,7 +94,7 @@ START_TEST(t_insert_with_mem_merges)
     uint64_t key = 0;
     uint32_t val = 0;
 
-    Rec r = {key, val};
+    R r = {key, val};
     for (size_t i=0; i<1000; i++) {
         ck_assert_int_eq(test_de->insert(r), 1);
         r.key++;
@@ -148,7 +148,7 @@ START_TEST(t_range_query)
 
     size_t i=0;
     while ( i < keys.size()) {
-        Rec r = {keys[i], (uint32_t) i};
+        R r = {keys[i], (uint32_t) i};
         if (test_de->insert(r)) {
             i++;
         } else {
@@ -166,7 +166,7 @@ START_TEST(t_range_query)
     uint64_t lower_key = keys[idx];
     uint64_t upper_key = keys[idx + 250];
 
-    rq::Parms<Rec> p;
+    rq::Parms<R> p;
     p.lower_bound = lower_key;
     p.upper_bound = upper_key;
 
@@ -210,7 +210,7 @@ START_TEST(t_tombstone_merging_01)
     size_t deletes = 0;
     size_t cnt=0;
     for (auto rec : records) {
-        Rec r = {rec.first, rec.second};
+        R r = {rec.first, rec.second};
         while (!test_de->insert(r)) {
             _mm_pause();
         }
@@ -220,7 +220,7 @@ START_TEST(t_tombstone_merging_01)
             std::sample(to_delete.begin(), to_delete.end(), std::back_inserter(del_vec), 3, std::mt19937{std::random_device{}()});
 
             for (size_t i=0; i<del_vec.size(); i++) {
-                Rec dr = {del_vec[i].first, del_vec[i].second};
+                R dr = {del_vec[i].first, del_vec[i].second};
                 while (!test_de->erase(dr)) {
                     _mm_pause();
                 }
@@ -249,9 +249,9 @@ DE *create_test_tree(size_t reccnt, size_t memlevel_cnt) {
 
     auto test_de = new DE(1000, 10000, 2);
 
-    std::set<Rec> records; 
-    std::set<Rec> to_delete;
-    std::set<Rec> deleted;
+    std::set<R> records; 
+    std::set<R> to_delete;
+    std::set<R> deleted;
 
     while (records.size() < reccnt) {
         uint64_t key = rand();
@@ -267,7 +267,7 @@ DE *create_test_tree(size_t reccnt, size_t memlevel_cnt) {
         ck_assert_int_eq(test_de->insert(rec), 1);
 
          if (gsl_rng_uniform(rng) < 0.05 && !to_delete.empty()) {
-            std::vector<Rec> del_vec;
+            std::vector<R> del_vec;
             std::sample(to_delete.begin(), to_delete.end(), std::back_inserter(del_vec), 3, std::mt19937{std::random_device{}()});
 
             for (size_t i=0; i<del_vec.size(); i++) {
@@ -295,9 +295,9 @@ START_TEST(t_static_structure)
     size_t reccnt = 100000;
     auto test_de = new DE(100, 1000, 2);
 
-    std::set<Rec> records; 
-    std::set<Rec> to_delete;
-    std::set<Rec> deleted;
+    std::set<R> records; 
+    std::set<R> to_delete;
+    std::set<R> deleted;
 
     while (records.size() < reccnt) {
         uint64_t key = rand();
@@ -319,7 +319,7 @@ START_TEST(t_static_structure)
         t_reccnt++;
 
          if (gsl_rng_uniform(rng) < 0.05 && !to_delete.empty()) {
-            std::vector<Rec> del_vec;
+            std::vector<R> del_vec;
             std::sample(to_delete.begin(), to_delete.end(), std::back_inserter(del_vec), 3, std::mt19937{std::random_device{}()});
 
             for (size_t i=0; i<del_vec.size(); i++) {
@@ -339,11 +339,11 @@ START_TEST(t_static_structure)
     }
 
 
-    //fprintf(stderr, "Tombstones: %ld\tRecords: %ld\n", test_de->get_tombstone_count(), test_de->get_record_count());
+    //fprintf(stderr, "Tombstones: %ld\tRords: %ld\n", test_de->get_tombstone_count(), test_de->get_record_count());
     //fprintf(stderr, "Inserts: %ld\tDeletes:%ld\tNet:%ld\n", reccnt, deletes, reccnt - deletes);
 
     auto flat = test_de->create_static_structure(true);
-    //fprintf(stderr, "Flat: Tombstones: %ld\tRecords %ld\n", flat->get_tombstone_count(), flat->get_record_count());
+    //fprintf(stderr, "Flat: Tombstones: %ld\tRords %ld\n", flat->get_tombstone_count(), flat->get_record_count());
     //ck_assert_int_eq(flat->get_record_count(), reccnt - deletes);
 
     uint64_t prev_key = 0;
diff --git a/tests/include/dynamic_extension.h b/tests/include/dynamic_extension.h
index 5a08f5a..f0f13dd 100644
--- a/tests/include/dynamic_extension.h
+++ b/tests/include/dynamic_extension.h
@@ -8,8 +8,8 @@
  * Distributed under the Modified BSD License.
  *
  * WARNING: This file must be included in the main unit test set
- *          after the definition of an appropriate Shard, Query, and Rec
- *          type. In particular, Rec needs to implement the key-value
+ *          after the definition of an appropriate Shard, Query, and R
+ *          type. In particular, R needs to implement the key-value
  *          pair interface. For other types of record, you'll need to
  *          use a different set of unit tests.
  */
@@ -29,7 +29,7 @@
 //#include "query/rangequery.h"
 //#include <check.h>
 //using namespace de;
-//typedef DynamicExtension<Rec, ISAMTree<Rec>, rq::Query<ISAMTree<Rec>, Rec>, LayoutPolicy::TEIRING, DeletePolicy::TAGGING, SerialScheduler> DE;
+//typedef DynamicExtension<R, ISAMTree<R>, rq::Query<ISAMTree<R>, R>, LayoutPolicy::TEIRING, DeletePolicy::TAGGING, SerialScheduler> DE;
 
 
 START_TEST(t_create)
@@ -52,7 +52,7 @@ START_TEST(t_insert)
     uint64_t key = 0;
     uint32_t val = 0;
     for (size_t i=0; i<100; i++) {
-        Rec r = {key, val};
+        R r = {key, val};
         ck_assert_int_eq(test_de->insert(r), 1);
         key++;
         val++;
@@ -73,7 +73,7 @@ START_TEST(t_debug_insert)
     uint64_t key = 0;
     uint32_t val = 0;
     for (size_t i=0; i<1000; i++) {
-        Rec r = {key, val};
+        R r = {key, val};
         ck_assert_int_eq(test_de->insert(r), 1);
         ck_assert_int_eq(test_de->get_record_count(), i+1);
         key++;
@@ -92,7 +92,7 @@ START_TEST(t_insert_with_mem_merges)
     uint64_t key = 0;
     uint32_t val = 0;
     for (size_t i=0; i<300; i++) {
-        Rec r = {key, val};
+        R r = {key, val};
         ck_assert_int_eq(test_de->insert(r), 1);
         key++;
         val++;
@@ -123,7 +123,7 @@ START_TEST(t_range_query)
     std::shuffle(keys.begin(), keys.end(), gen);
 
     for (size_t i=0; i<keys.size(); i++) {
-        Rec r = {keys[i], (uint32_t) i};
+        R r = {keys[i], (uint32_t) i};
         ck_assert_int_eq(test_de->insert(r), 1);
     }
 
@@ -136,7 +136,7 @@ START_TEST(t_range_query)
     uint64_t lower_key = keys[idx];
     uint64_t upper_key = keys[idx + 250];
 
-    rq::Parms<Rec> p;
+    rq::Parms<R> p;
     p.lower_bound = lower_key;
     p.upper_bound = upper_key;
 
@@ -177,7 +177,7 @@ START_TEST(t_tombstone_merging_01)
     size_t deletes = 0;
     size_t cnt=0;
     for (auto rec : records) {
-        Rec r = {rec.first, rec.second};
+        R r = {rec.first, rec.second};
         ck_assert_int_eq(test_de->insert(r), 1);
 
          if (gsl_rng_uniform(rng) < 0.05 && !to_delete.empty()) {
@@ -185,7 +185,7 @@ START_TEST(t_tombstone_merging_01)
             std::sample(to_delete.begin(), to_delete.end(), std::back_inserter(del_vec), 3, std::mt19937{std::random_device{}()});
 
             for (size_t i=0; i<del_vec.size(); i++) {
-                Rec dr = {del_vec[i].first, del_vec[i].second};
+                R dr = {del_vec[i].first, del_vec[i].second};
                 test_de->erase(dr);
                 deletes++;
                 to_delete.erase(del_vec[i]);
@@ -212,9 +212,9 @@ DE *create_test_tree(size_t reccnt, size_t memlevel_cnt) {
 
     auto test_de = new DE(1000, 10000, 2);
 
-    std::set<Rec> records; 
-    std::set<Rec> to_delete;
-    std::set<Rec> deleted;
+    std::set<R> records; 
+    std::set<R> to_delete;
+    std::set<R> deleted;
 
     while (records.size() < reccnt) {
         uint64_t key = rand();
@@ -230,7 +230,7 @@ DE *create_test_tree(size_t reccnt, size_t memlevel_cnt) {
         ck_assert_int_eq(test_de->insert(rec), 1);
 
          if (gsl_rng_uniform(rng) < 0.05 && !to_delete.empty()) {
-            std::vector<Rec> del_vec;
+            std::vector<R> del_vec;
             std::sample(to_delete.begin(), to_delete.end(), std::back_inserter(del_vec), 3, std::mt19937{std::random_device{}()});
 
             for (size_t i=0; i<del_vec.size(); i++) {
@@ -258,9 +258,9 @@ START_TEST(t_static_structure)
     size_t reccnt = 100000;
     auto test_de = new DE(100, 1000, 2);
 
-    std::set<Rec> records; 
-    std::set<Rec> to_delete;
-    std::set<Rec> deleted;
+    std::set<R> records; 
+    std::set<R> to_delete;
+    std::set<R> deleted;
 
     while (records.size() < reccnt) {
         uint64_t key = rand();
@@ -280,7 +280,7 @@ START_TEST(t_static_structure)
         t_reccnt++;
 
          if (gsl_rng_uniform(rng) < 0.05 && !to_delete.empty()) {
-            std::vector<Rec> del_vec;
+            std::vector<R> del_vec;
             std::sample(to_delete.begin(), to_delete.end(), std::back_inserter(del_vec), 3, std::mt19937{std::random_device{}()});
 
             for (size_t i=0; i<del_vec.size(); i++) {
diff --git a/tests/include/rangecount.h b/tests/include/rangecount.h
index 471af27..fdd66d9 100644
--- a/tests/include/rangecount.h
+++ b/tests/include/rangecount.h
@@ -9,8 +9,8 @@
  * Distributed under the Modified BSD License.
  *
  * WARNING: This file must be included in the main unit test set
- *          after the definition of an appropriate Shard and Rec
- *          type. In particular, Rec needs to implement the key-value
+ *          after the definition of an appropriate Shard and R
+ *          type. In particular, R needs to implement the key-value
  *          pair interface and Shard needs to support lower_bound. 
  *          For other types of record and shard, you'll need to
  *          use a different set of unit tests.
@@ -29,21 +29,24 @@
 //#include "testing.h"
 //#include <check.h>
 //using namespace de;
-//typedef ISAMTree<Rec> Shard;
+//typedef ISAMTree<R> Shard;
+
+
+#include "query/rangecount.h"
 
 START_TEST(t_range_count)
 {
     
-    auto buffer = create_sequential_mbuffer<Rec>(100, 1000);
+    auto buffer = create_sequential_mbuffer<R>(100, 1000);
     auto shard = Shard(buffer->get_buffer_view());
 
-    rc::Parms<Rec> parms;
+    rc::Parms<R> parms;
     parms.lower_bound = 300;
     parms.upper_bound = 500;
 
-    auto state = rc::Query<Rec, Shard>::get_query_state(&shard, &parms);
-    auto result = rc::Query<Rec, Shard>::query(&shard, state, &parms);
-    rc::Query<Rec, Shard>::delete_query_state(state);
+    auto state = rc::Query<R, Shard>::get_query_state(&shard, &parms);
+    auto result = rc::Query<R, Shard>::query(&shard, state, &parms);
+    rc::Query<R, Shard>::delete_query_state(state);
 
     ck_assert_int_eq(result.size(), 1);
     ck_assert_int_eq(result[0].rec.key, parms.upper_bound - parms.lower_bound + 1);
@@ -55,17 +58,17 @@ END_TEST
 
 START_TEST(t_buffer_range_count)
 {
-    auto buffer = create_sequential_mbuffer<Rec>(100, 1000);
+    auto buffer = create_sequential_mbuffer<R>(100, 1000);
 
-    rc::Parms<Rec> parms;
+    rc::Parms<R> parms;
     parms.lower_bound = 300;
     parms.upper_bound = 500;
 
     {
         auto view = buffer->get_buffer_view();
-        auto state = rc::Query<Rec, Shard>::get_buffer_query_state(&view, &parms);
-        auto result = rc::Query<Rec, Shard>::buffer_query(state, &parms);
-        rc::Query<Rec, Shard>::delete_buffer_query_state(state);
+        auto state = rc::Query<R, Shard>::get_buffer_query_state(&view, &parms);
+        auto result = rc::Query<R, Shard>::buffer_query(state, &parms);
+        rc::Query<R, Shard>::delete_buffer_query_state(state);
 
         ck_assert_int_eq(result.size(), 1);
         ck_assert_int_eq(result[0].rec.key, parms.upper_bound - parms.lower_bound + 1);
@@ -78,32 +81,32 @@ END_TEST
 
 START_TEST(t_range_count_merge)
 {    
-    auto buffer1 = create_sequential_mbuffer<Rec>(100, 200);
-    auto buffer2 = create_sequential_mbuffer<Rec>(400, 1000);
+    auto buffer1 = create_sequential_mbuffer<R>(100, 200);
+    auto buffer2 = create_sequential_mbuffer<R>(400, 1000);
 
     auto shard1 = Shard(buffer1->get_buffer_view());
     auto shard2 = Shard(buffer2->get_buffer_view());
 
-    rc::Parms<Rec> parms;
+    rc::Parms<R> parms;
     parms.lower_bound = 150;
     parms.upper_bound = 500;
 
     size_t result_size = parms.upper_bound - parms.lower_bound + 1 - 200;
 
-    auto state1 = rc::Query<Rec, Shard>::get_query_state(&shard1, &parms);
-    auto state2 = rc::Query<Rec, Shard>::get_query_state(&shard2, &parms);
+    auto state1 = rc::Query<R, Shard>::get_query_state(&shard1, &parms);
+    auto state2 = rc::Query<R, Shard>::get_query_state(&shard2, &parms);
 
-    std::vector<std::vector<de::Wrapped<Rec>>> results(2);
-    results[0] = rc::Query<Rec, Shard>::query(&shard1, state1, &parms);
-    results[1] = rc::Query<Rec, Shard>::query(&shard2, state2, &parms);
+    std::vector<std::vector<de::Wrapped<R>>> results(2);
+    results[0] = rc::Query<R, Shard>::query(&shard1, state1, &parms);
+    results[1] = rc::Query<R, Shard>::query(&shard2, state2, &parms);
 
-    rc::Query<Rec, Shard>::delete_query_state(state1);
-    rc::Query<Rec, Shard>::delete_query_state(state2);
+    rc::Query<R, Shard>::delete_query_state(state1);
+    rc::Query<R, Shard>::delete_query_state(state2);
 
     ck_assert_int_eq(results[0].size(), 1);
     ck_assert_int_eq(results[1].size(), 1);
 
-    auto result = rc::Query<Rec, Shard>::merge(results, nullptr);
+    auto result = rc::Query<R, Shard>::merge(results, nullptr);
 
     ck_assert_int_eq(result[0].key, result_size);
 
@@ -115,8 +118,8 @@ END_TEST
 
 START_TEST(t_lower_bound)
 {
-    auto buffer1 = create_sequential_mbuffer<Rec>(100, 200);
-    auto buffer2 = create_sequential_mbuffer<Rec>(400, 1000);
+    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());
@@ -126,7 +129,7 @@ START_TEST(t_lower_bound)
     auto merged = Shard(shards);
 
     for (size_t i=100; i<1000; i++) {
-        Rec r;
+        R r;
         r.key = i;
         r.value = i;
 
diff --git a/tests/include/rangequery.h b/tests/include/rangequery.h
index dbb71db..a8a73f7 100644
--- a/tests/include/rangequery.h
+++ b/tests/include/rangequery.h
@@ -9,8 +9,8 @@
  * Distributed under the Modified BSD License.
  *
  * WARNING: This file must be included in the main unit test set
- *          after the definition of an appropriate Shard and Rec
- *          type. In particular, Rec needs to implement the key-value
+ *          after the definition of an appropriate Shard and R
+ *          type. In particular, R needs to implement the key-value
  *          pair interface and Shard needs to support lower_bound. 
  *          For other types of record and shard, you'll need to
  *          use a different set of unit tests.
@@ -29,21 +29,23 @@
 //#include "testing.h"
 //#include <check.h>
 //using namespace de;
-//typedef ISAMTree<Rec> Shard;
+//typedef ISAMTree<R> Shard;
+
+#include "query/rangequery.h"
 
 
 START_TEST(t_range_query)
 {
-    auto buffer = create_sequential_mbuffer<Rec>(100, 1000);
+    auto buffer = create_sequential_mbuffer<R>(100, 1000);
     auto shard = Shard(buffer->get_buffer_view());
 
-    rq::Parms<Rec> parms;
+    rq::Parms<R> parms;
     parms.lower_bound = 300;
     parms.upper_bound = 500;
 
-    auto state = rq::Query<Rec, Shard>::get_query_state(&shard, &parms);
-    auto result = rq::Query<Rec, Shard>::query(&shard, state, &parms);
-    rq::Query<Rec, Shard>::delete_query_state(state);
+    auto state = rq::Query<R, Shard>::get_query_state(&shard, &parms);
+    auto result = rq::Query<R, Shard>::query(&shard, state, &parms);
+    rq::Query<R, Shard>::delete_query_state(state);
 
     ck_assert_int_eq(result.size(), parms.upper_bound - parms.lower_bound + 1);
     for (size_t i=0; i<result.size(); i++) {
@@ -58,17 +60,17 @@ END_TEST
 
 START_TEST(t_buffer_range_query)
 {
-    auto buffer = create_sequential_mbuffer<Rec>(100, 1000);
+    auto buffer = create_sequential_mbuffer<R>(100, 1000);
 
-    rq::Parms<Rec> parms;
+    rq::Parms<R> parms;
     parms.lower_bound = 300;
     parms.upper_bound = 500;
 
     {
         auto view = buffer->get_buffer_view();
-        auto state = rq::Query<Rec, Shard>::get_buffer_query_state(&view, &parms);
-        auto result = rq::Query<Rec, Shard>::buffer_query(state, &parms);
-        rq::Query<Rec, Shard>::delete_buffer_query_state(state);
+        auto state = rq::Query<R, Shard>::get_buffer_query_state(&view, &parms);
+        auto result = rq::Query<R, Shard>::buffer_query(state, &parms);
+        rq::Query<R, Shard>::delete_buffer_query_state(state);
 
         ck_assert_int_eq(result.size(), parms.upper_bound - parms.lower_bound + 1);
         for (size_t i=0; i<result.size(); i++) {
@@ -84,40 +86,40 @@ END_TEST
 
 START_TEST(t_range_query_merge)
 {    
-    auto buffer1 = create_sequential_mbuffer<Rec>(100, 200);
-    auto buffer2 = create_sequential_mbuffer<Rec>(400, 1000);
+    auto buffer1 = create_sequential_mbuffer<R>(100, 200);
+    auto buffer2 = create_sequential_mbuffer<R>(400, 1000);
 
     auto shard1 = Shard(buffer1->get_buffer_view());
     auto shard2 = Shard(buffer2->get_buffer_view());
 
-    rq::Parms<Rec> parms;
+    rq::Parms<R> parms;
     parms.lower_bound = 150;
     parms.upper_bound = 500;
 
     size_t result_size = parms.upper_bound - parms.lower_bound + 1 - 200;
 
-    auto state1 = rq::Query<Rec, Shard>::get_query_state(&shard1, &parms);
-    auto state2 = rq::Query<Rec, Shard>::get_query_state(&shard2, &parms);
+    auto state1 = rq::Query<R, Shard>::get_query_state(&shard1, &parms);
+    auto state2 = rq::Query<R, Shard>::get_query_state(&shard2, &parms);
 
-    std::vector<std::vector<de::Wrapped<Rec>>> results(2);
-    results[0] = rq::Query<Rec, Shard>::query(&shard1, state1, &parms);
-    results[1] = rq::Query<Rec, Shard>::query(&shard2, state2, &parms);
+    std::vector<std::vector<de::Wrapped<R>>> results(2);
+    results[0] = rq::Query<R, Shard>::query(&shard1, state1, &parms);
+    results[1] = rq::Query<R, Shard>::query(&shard2, state2, &parms);
 
-    rq::Query<Rec, Shard>::delete_query_state(state1);
-    rq::Query<Rec, Shard>::delete_query_state(state2);
+    rq::Query<R, Shard>::delete_query_state(state1);
+    rq::Query<R, Shard>::delete_query_state(state2);
 
     ck_assert_int_eq(results[0].size() + results[1].size(), result_size);
 
-    std::vector<std::vector<Wrapped<Rec>>> proc_results;
+    std::vector<std::vector<Wrapped<R>>> proc_results;
 
     for (size_t j=0; j<results.size(); j++) {
-        proc_results.emplace_back(std::vector<Wrapped<Rec>>());
+        proc_results.emplace_back(std::vector<Wrapped<R>>());
         for (size_t i=0; i<results[j].size(); i++) {
             proc_results[j].emplace_back(results[j][i]);
         }
     }
 
-    auto result = rq::Query<Rec, Shard>::merge(proc_results, nullptr);
+    auto result = rq::Query<R, Shard>::merge(proc_results, nullptr);
     std::sort(result.begin(), result.end());
 
     ck_assert_int_eq(result.size(), result_size);
@@ -137,8 +139,8 @@ END_TEST
 
 START_TEST(t_lower_bound)
 {
-    auto buffer1 = create_sequential_mbuffer<Rec>(100, 200);
-    auto buffer2 = create_sequential_mbuffer<Rec>(400, 1000);
+    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());
@@ -148,7 +150,7 @@ START_TEST(t_lower_bound)
     auto merged = Shard(shards);
 
     for (size_t i=100; i<1000; i++) {
-        Rec r;
+        R r;
         r.key = i;
         r.value = i;
 
diff --git a/tests/include/shard_standard.h b/tests/include/shard_standard.h
index ddd7614..f50c1cb 100644
--- a/tests/include/shard_standard.h
+++ b/tests/include/shard_standard.h
@@ -8,8 +8,8 @@
  * Distributed under the Modified BSD License.
  *
  * WARNING: This file must be included in the main unit test set
- *          after the definition of an appropriate Shard and Rec
- *          type. In particular, Rec needs to implement the key-value
+ *          after the definition of an appropriate Shard and R
+ *          type. In particular, R needs to implement the key-value
  *          pair interface. For other types of record, you'll need to
  *          use a different set of unit tests.
  */
@@ -26,11 +26,11 @@
 //#include "testing.h"
 //#include <check.h>
 //using namespace de;
-//typedef ISAMTree<Rec> Shard;
+//typedef ISAMTree<R> Shard;
 
 START_TEST(t_mbuffer_init)
 {
-    auto buffer = new MutableBuffer<Rec>(512, 1024);
+    auto buffer = new MutableBuffer<R>(512, 1024);
     for (uint64_t i = 512; i > 0; i--) {
         uint32_t v = i;
         buffer->append({i,v, 1});
@@ -57,9 +57,9 @@ START_TEST(t_mbuffer_init)
 START_TEST(t_shard_init)
 {
     size_t n = 512;
-    auto mbuffer1 = create_test_mbuffer<Rec>(n);
-    auto mbuffer2 = create_test_mbuffer<Rec>(n);
-    auto mbuffer3 = create_test_mbuffer<Rec>(n);
+    auto mbuffer1 = create_test_mbuffer<R>(n);
+    auto mbuffer2 = create_test_mbuffer<R>(n);
+    auto mbuffer3 = create_test_mbuffer<R>(n);
 
     auto shard1 = new Shard(mbuffer1->get_buffer_view());
     auto shard2 = new Shard(mbuffer2->get_buffer_view());
@@ -108,8 +108,8 @@ START_TEST(t_shard_init)
 START_TEST(t_full_cancelation)
 {
     size_t n = 100;
-    auto buffer = create_double_seq_mbuffer<Rec>(n, false);
-    auto buffer_ts = create_double_seq_mbuffer<Rec>(n, true);
+    auto buffer = create_double_seq_mbuffer<R>(n, false);
+    auto buffer_ts = create_double_seq_mbuffer<R>(n, true);
 
     Shard* shard = new Shard(buffer->get_buffer_view());
     Shard* shard_ts = new Shard(buffer_ts->get_buffer_view());
@@ -139,14 +139,14 @@ START_TEST(t_point_lookup)
 {
     size_t n = 10000;
 
-    auto buffer = create_double_seq_mbuffer<Rec>(n, false);
+    auto buffer = create_double_seq_mbuffer<R>(n, false);
     auto isam = Shard(buffer->get_buffer_view());
 
     {
         auto view = buffer->get_buffer_view();
 
         for (size_t i=0; i<n; i++) {
-            Rec r;
+            R r;
             auto rec = view.get(i);
             r.key = rec->rec.key;
             r.value = rec->rec.value;
@@ -167,11 +167,11 @@ START_TEST(t_point_lookup_miss)
 {
     size_t n = 10000;
 
-    auto buffer = create_double_seq_mbuffer<Rec>(n, false);
+    auto buffer = create_double_seq_mbuffer<R>(n, false);
     auto isam = Shard(buffer->get_buffer_view());
 
     for (size_t i=n + 100; i<2*n; i++) {
-        Rec r;
+        R r;
         r.key = i;
         r.value = i;
 
diff --git a/tests/include/wirs.h b/tests/include/wirs.h
new file mode 100644
index 0000000..90cd22d
--- /dev/null
+++ b/tests/include/wirs.h
@@ -0,0 +1,181 @@
+/*
+ * tests/include/rangequery.h
+ *
+ * Standardized unit tests for range queries against supporting
+ * shard types
+ *
+ * Copyright (C) 2023 Douglas Rumbaugh <drumbaugh@psu.edu> 
+ *
+ * Distributed under the Modified BSD License.
+ *
+ * WARNING: This file must be included in the main unit test set
+ *          after the definition of an appropriate Shard and R
+ *          type. In particular, R needs to implement the key-value
+ *          pair interface and Shard needs to support lower_bound. 
+ *          For other types of record and shard, you'll need to
+ *          use a different set of unit tests.
+ */
+#pragma once
+
+/*
+ * Uncomment these lines temporarily to remove errors in this file
+ * temporarily for development purposes. They should be removed prior
+ * to building, to ensure no duplicate definitions. These includes/defines
+ * should be included in the source file that includes this one, above the
+ * include statement.
+ */
+//#include "shard/ISAMTree.h"
+//#include "query/rangequery.h"
+//#include "testing.h"
+//#include <check.h>
+//using namespace de;
+//typedef ISAMTree<R> Shard;
+
+
+START_TEST(t_range_query)
+{
+    auto buffer = create_sequential_mbuffer<R>(100, 1000);
+    auto shard = Shard(buffer->get_buffer_view());
+
+    rq::Parms<R> parms;
+    parms.lower_bound = 300;
+    parms.upper_bound = 500;
+
+    auto state = rq::Query<R, Shard>::get_query_state(&shard, &parms);
+    auto result = rq::Query<R, Shard>::query(&shard, state, &parms);
+    rq::Query<R, Shard>::delete_query_state(state);
+
+    ck_assert_int_eq(result.size(), parms.upper_bound - parms.lower_bound + 1);
+    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);
+    }
+
+    delete buffer;
+}
+END_TEST
+
+
+START_TEST(t_buffer_range_query)
+{
+    auto buffer = create_sequential_mbuffer<R>(100, 1000);
+
+    rq::Parms<R> parms;
+    parms.lower_bound = 300;
+    parms.upper_bound = 500;
+
+    {
+        auto view = buffer->get_buffer_view();
+        auto state = rq::Query<R, Shard>::get_buffer_query_state(&view, &parms);
+        auto result = rq::Query<R, Shard>::buffer_query(state, &parms);
+        rq::Query<R, Shard>::delete_buffer_query_state(state);
+
+        ck_assert_int_eq(result.size(), parms.upper_bound - parms.lower_bound + 1);
+        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);
+        }
+    }
+
+    delete buffer;
+}
+END_TEST
+
+
+START_TEST(t_range_query_merge)
+{    
+    auto buffer1 = create_sequential_mbuffer<R>(100, 200);
+    auto buffer2 = create_sequential_mbuffer<R>(400, 1000);
+
+    auto shard1 = Shard(buffer1->get_buffer_view());
+    auto shard2 = Shard(buffer2->get_buffer_view());
+
+    rq::Parms<R> parms;
+    parms.lower_bound = 150;
+    parms.upper_bound = 500;
+
+    size_t result_size = parms.upper_bound - parms.lower_bound + 1 - 200;
+
+    auto state1 = rq::Query<R, Shard>::get_query_state(&shard1, &parms);
+    auto state2 = rq::Query<R, Shard>::get_query_state(&shard2, &parms);
+
+    std::vector<std::vector<de::Wrapped<R>>> results(2);
+    results[0] = rq::Query<R, Shard>::query(&shard1, state1, &parms);
+    results[1] = rq::Query<R, Shard>::query(&shard2, state2, &parms);
+
+    rq::Query<R, Shard>::delete_query_state(state1);
+    rq::Query<R, Shard>::delete_query_state(state2);
+
+    ck_assert_int_eq(results[0].size() + results[1].size(), result_size);
+
+    std::vector<std::vector<Wrapped<R>>> proc_results;
+
+    for (size_t j=0; j<results.size(); j++) {
+        proc_results.emplace_back(std::vector<Wrapped<R>>());
+        for (size_t i=0; i<results[j].size(); i++) {
+            proc_results[j].emplace_back(results[j][i]);
+        }
+    }
+
+    auto result = rq::Query<R, Shard>::merge(proc_results, nullptr);
+    std::sort(result.begin(), result.end());
+
+    ck_assert_int_eq(result.size(), result_size);
+    auto key = parms.lower_bound;
+    for (size_t i=0; i<result.size(); i++) {
+        ck_assert_int_eq(key++, result[i].key);
+        if (key == 200) {
+            key = 400;
+        }
+    }
+
+    delete buffer1;
+    delete buffer2;
+}
+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 (size_t i=100; i<1000; i++) {
+        R r;
+        r.key = i;
+        r.value = 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) {
+    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); 
+    tcase_add_test(range_query, t_range_query_merge); 
+    suite_add_tcase(suite, range_query);
+}
diff --git a/tests/include/wss.h b/tests/include/wss.h
new file mode 100644
index 0000000..f0ac74c
--- /dev/null
+++ b/tests/include/wss.h
@@ -0,0 +1,144 @@
+/*
+ * tests/include/rangequery.h
+ *
+ * Standardized unit tests for range queries against supporting
+ * shard types
+ *
+ * Copyright (C) 2023 Douglas Rumbaugh <drumbaugh@psu.edu> 
+ *
+ * Distributed under the Modified BSD License.
+ *
+ * WARNING: This file must be included in the main unit test set
+ *          after the definition of an appropriate Shard and R
+ *          type. In particular, R needs to implement the key-value
+ *          pair interface and Shard needs to support lower_bound. 
+ *          For other types of record and shard, you'll need to
+ *          use a different set of unit tests.
+ */
+#pragma once
+
+/*
+ * Uncomment these lines temporarily to remove errors in this file
+ * temporarily for development purposes. They should be removed prior
+ * to building, to ensure no duplicate definitions. These includes/defines
+ * should be included in the source file that includes this one, above the
+ * include statement.
+ */
+#include "shard/Alias.h"
+#include "testing.h"
+#include <check.h>
+using namespace de;
+typedef Alias<R> Shard;
+
+#include "query/wss.h"
+
+START_TEST(t_wss_query)
+{
+    auto buffer = create_weighted_mbuffer<R>(1000);
+    auto shard = Shard(buffer->get_buffer_view());
+
+    auto rng = gsl_rng_alloc(gsl_rng_mt19937);
+
+    wss::Parms<R> parms;
+    parms.rng = rng;
+    parms.sample_size = 20;
+
+    auto state = wss::Query<R, Shard>::get_query_state(&shard, &parms);
+    auto result = wss::Query<R, Shard>::query(&shard, state, &parms);
+    wss::Query<R, Shard>::delete_query_state(state);
+
+    delete buffer;
+    gsl_rng_free(rng);
+}
+END_TEST
+
+
+START_TEST(t_buffer_wss_query)
+{
+    auto buffer = create_weighted_mbuffer<R>(1000);
+
+
+    auto rng = gsl_rng_alloc(gsl_rng_mt19937);
+
+    wss::Parms<R> parms;
+    parms.rng = rng;
+
+    {
+        auto view = buffer->get_buffer_view();
+        auto state = wss::Query<R, Shard>::get_buffer_query_state(&view, &parms);
+        auto result = wss::Query<R, Shard>::buffer_query(state, &parms);
+        wss::Query<R, Shard>::delete_buffer_query_state(state);
+
+        ck_assert_int_eq(result.size(), parms.sample_size);
+        for (size_t i=0; i<result.size(); i++) {
+            
+        }
+    }
+
+    delete buffer;
+}
+END_TEST
+
+
+/*
+START_TEST(t_range_query_merge)
+{    
+    auto buffer1 = create_sequential_mbuffer<R>(100, 200);
+    auto buffer2 = create_sequential_mbuffer<R>(400, 1000);
+
+    auto shard1 = Shard(buffer1->get_buffer_view());
+    auto shard2 = Shard(buffer2->get_buffer_view());
+
+    wss::Parms<R> parms;
+    parms.lower_bound = 150;
+    parms.upper_bound = 500;
+
+    size_t result_size = parms.upper_bound - parms.lower_bound + 1 - 200;
+
+    auto state1 = wss::Query<R, Shard>::get_query_state(&shard1, &parms);
+    auto state2 = wss::Query<R, Shard>::get_query_state(&shard2, &parms);
+
+    std::vector<std::vector<de::Wrapped<R>>> results(2);
+    results[0] = wss::Query<R, Shard>::query(&shard1, state1, &parms);
+    results[1] = wss::Query<R, Shard>::query(&shard2, state2, &parms);
+
+    wss::Query<R, Shard>::delete_query_state(state1);
+    wss::Query<R, Shard>::delete_query_state(state2);
+
+    ck_assert_int_eq(results[0].size() + results[1].size(), result_size);
+
+    std::vector<std::vector<Wrapped<R>>> proc_results;
+
+    for (size_t j=0; j<results.size(); j++) {
+        proc_results.emplace_back(std::vector<Wrapped<R>>());
+        for (size_t i=0; i<results[j].size(); i++) {
+            proc_results[j].emplace_back(results[j][i]);
+        }
+    }
+
+    auto result = wss::Query<R, Shard>::merge(proc_results, nullptr);
+    std::sort(result.begin(), result.end());
+
+    ck_assert_int_eq(result.size(), result_size);
+    auto key = parms.lower_bound;
+    for (size_t i=0; i<result.size(); i++) {
+        ck_assert_int_eq(key++, result[i].key);
+        if (key == 200) {
+            key = 400;
+        }
+    }
+
+    delete buffer1;
+    delete buffer2;
+}
+END_TEST
+*/
+
+
+static void inject_wss_tests(Suite *suite) {
+    TCase *wss_query = tcase_create("WSS Query Testing"); 
+    tcase_add_test(wss_query, t_wss_query); 
+    tcase_add_test(wss_query, t_buffer_wss_query); 
+    //tcase_add_test(wss_query, t_wss_query_merge); 
+    suite_add_tcase(suite, wss_query);
+}