From e02742b07540dd5a9bcbb44dae14856bf10955ed Mon Sep 17 00:00:00 2001
From: Douglas Rumbaugh <dbr4@psu.edu>
Date: Mon, 6 Nov 2023 15:18:53 -0500
Subject: Refactoring progress

---
 tests/alias_tests.cpp      | 391 +++++++++++++++++++++++++++++++++++++++++++++
 tests/memisam_tests.cpp    |  69 ++++----
 tests/pgm_tests.cpp        |  33 ++--
 tests/triespline_tests.cpp |  17 +-
 tests/wss_tests.cpp        | 390 --------------------------------------------
 5 files changed, 452 insertions(+), 448 deletions(-)
 create mode 100644 tests/alias_tests.cpp
 delete mode 100644 tests/wss_tests.cpp

(limited to 'tests')

diff --git a/tests/alias_tests.cpp b/tests/alias_tests.cpp
new file mode 100644
index 0000000..b9e678b
--- /dev/null
+++ b/tests/alias_tests.cpp
@@ -0,0 +1,391 @@
+/*
+ * tests/alias_tests.cpp
+ *
+ * Unit tests for Alias shard
+ *
+ * Copyright (C) 2023 Douglas Rumbaugh <drumbaugh@psu.edu> 
+ *                    Dong Xie <dongx@psu.edu>
+ *
+ * All rights reserved. Published under the Modified BSD License.
+ *
+ */
+
+#include "shard/Alias.h"
+#include "query/wss.h"
+#include "testing.h"
+
+#include <check.h>
+
+using namespace de;
+
+typedef Alias<WRec> Shard;
+
+START_TEST(t_mbuffer_init)
+{
+    auto buffer = new MutableBuffer<WRec>(1024, 1024);
+    for (uint64_t i = 512; i > 0; i--) {
+        uint32_t v = i;
+        buffer->append({i,v, 1});
+    }
+    
+    for (uint64_t i = 1; i <= 256; ++i) {
+        uint32_t v = i;
+        buffer->append({i, v, 1}, true);
+    }
+
+    for (uint64_t i = 257; i <= 512; ++i) {
+        uint32_t v = i + 1;
+        buffer->append({i, v, 1});
+    }
+
+    Shard* shard = new Shard(buffer);
+    ck_assert_uint_eq(shard->get_record_count(), 512);
+
+    delete buffer;
+    delete shard;
+}
+
+
+START_TEST(t_alias_init)
+{
+    size_t n = 512;
+    auto mbuffer1 = create_test_mbuffer<WRec>(n);
+    auto mbuffer2 = create_test_mbuffer<WRec>(n);
+    auto mbuffer3 = create_test_mbuffer<WRec>(n);
+
+    auto shard1 = new Shard(mbuffer1);
+    auto shard2 = new Shard(mbuffer2);
+    auto shard3 = new Shard(mbuffer3);
+
+    Shard* shards[3] = {shard1, shard2, shard3};
+    auto shard4 = new Shard(shards, 3);
+
+    ck_assert_int_eq(shard4->get_record_count(), n * 3);
+    ck_assert_int_eq(shard4->get_tombstone_count(), 0);
+
+    size_t total_cnt = 0;
+    size_t shard1_idx = 0;
+    size_t shard2_idx = 0;
+    size_t shard3_idx = 0;
+
+    for (size_t i = 0; i < shard4->get_record_count(); ++i) {
+        auto rec1 = shard1->get_record_at(shard1_idx);
+        auto rec2 = shard2->get_record_at(shard2_idx);
+        auto rec3 = shard3->get_record_at(shard3_idx);
+
+        auto cur_rec = shard4->get_record_at(i);
+
+        if (shard1_idx < n && cur_rec->rec == rec1->rec) {
+            ++shard1_idx;
+        } else if (shard2_idx < n && cur_rec->rec == rec2->rec) {
+            ++shard2_idx;
+        } else if (shard3_idx < n && cur_rec->rec == rec3->rec) {
+            ++shard3_idx;
+        } else {
+           assert(false);
+        }
+    }
+
+    delete mbuffer1;
+    delete mbuffer2;
+    delete mbuffer3;
+
+    delete shard1;
+    delete shard2;
+    delete shard3;
+    delete shard4;
+}
+
+
+START_TEST(t_point_lookup) 
+{
+    size_t n = 10000;
+
+    auto buffer = create_double_seq_mbuffer<WRec>(n, false);
+    auto alias = Shard(buffer);
+
+    for (size_t i=0; i<n; i++) {
+        WRec r;
+        auto rec = (buffer->get_data() + i);
+        r.key = rec->rec.key;
+        r.value = rec->rec.value;
+
+        auto result = alias.point_lookup(r);
+        ck_assert_ptr_nonnull(result);
+        ck_assert_int_eq(result->rec.key, r.key);
+        ck_assert_int_eq(result->rec.value, r.value);
+    }
+
+    delete buffer;
+}
+END_TEST
+
+
+START_TEST(t_point_lookup_miss) 
+{
+    size_t n = 10000;
+
+    auto buffer = create_double_seq_mbuffer<WRec>(n, false);
+    auto alias = Shard(buffer);
+
+    for (size_t i=n + 100; i<2*n; i++) {
+        WRec r;
+        r.key = i;
+        r.value = i;
+
+        auto result = alias.point_lookup(r);
+        ck_assert_ptr_null(result);
+    }
+
+    delete buffer;
+}
+
+START_TEST(t_full_cancelation)
+{
+    size_t n = 100;
+    auto buffer = create_double_seq_mbuffer<WRec>(n, false);
+    auto buffer_ts = create_double_seq_mbuffer<WRec>(n, true);
+
+    Shard* shard = new Shard(buffer);
+    Shard* shard_ts = new Shard(buffer_ts);
+
+    ck_assert_int_eq(shard->get_record_count(), n);
+    ck_assert_int_eq(shard->get_tombstone_count(), 0);
+    ck_assert_int_eq(shard_ts->get_record_count(), n);
+    ck_assert_int_eq(shard_ts->get_tombstone_count(), n);
+
+    Shard* shards[] = {shard, shard_ts};
+
+    Shard* merged = new Shard(shards, 2);
+
+    ck_assert_int_eq(merged->get_tombstone_count(), 0);
+    ck_assert_int_eq(merged->get_record_count(), 0);
+
+    delete buffer;
+    delete buffer_ts;
+    delete shard;
+    delete shard_ts;
+    delete merged;
+}
+END_TEST
+
+
+START_TEST(t_alias_query)
+{
+    size_t n=1000;
+    auto buffer = create_weighted_mbuffer<WRec>(n);
+
+    Shard* shard = new Shard(buffer);
+
+    size_t k = 1000;
+
+    size_t cnt[3] = {0};
+    wss:Parms<WRec> parms = {k};
+    parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
+
+    size_t total_samples = 0;
+
+    for (size_t i=0; i<1000; i++) {
+        auto state = wss::Query<Shard, WRec>::get_query_state(shard, &parms);
+        ((wss::State<WRec> *) state)->sample_size = k;
+        auto result = wss::Query<Shard, WRec>::query(shard, state, &parms);
+
+        total_samples += result.size();
+
+        for (size_t j=0; j<result.size(); j++) {
+            cnt[result[j].rec.key - 1]++;
+        }
+
+        wss::Query<Shard, WRec>::delete_query_state(state);
+    }
+
+    ck_assert(roughly_equal(cnt[0], (double) total_samples/4.0, total_samples, .05));
+    ck_assert(roughly_equal(cnt[1], (double) total_samples/4.0, total_samples, .05));
+    ck_assert(roughly_equal(cnt[2], (double) total_samples/2.0, total_samples, .05));
+
+    gsl_rng_free(parms.rng);
+    delete shard;
+    delete buffer;
+}
+END_TEST
+
+
+START_TEST(t_alias_query_merge)
+{
+    size_t n=1000;
+    auto buffer = create_weighted_mbuffer<WRec>(n);
+
+    Shard* shard = new Shard(buffer);
+
+    uint64_t lower_key = 0;
+    uint64_t upper_key = 5;
+
+    size_t k = 1000;
+
+    size_t cnt[3] = {0};
+    wss:Parms<WRec> parms = {k};
+    parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
+
+    std::vector<std::vector<Wrapped<WRec>>> results(2);
+
+    for (size_t i=0; i<1000; i++) {
+        auto state1 = wss::Query<Shard, WRec>::get_query_state(shard, &parms);
+        ((wss::State<WRec> *) state1)->sample_size = k;
+        results[0] = wss::Query<Shard, WRec>::query(shard, state1, &parms);
+
+        auto state2 = wss::Query<Shard, WRec>::get_query_state(shard, &parms);
+        ((wss::State<WRec> *) state2)->sample_size = k;
+        results[1] = wss::Query<Shard, WRec>::query(shard, state2, &parms);
+
+        wss::Query<Shard, WRec>::delete_query_state(state1);
+        wss::Query<Shard, WRec>::delete_query_state(state2);
+    }
+
+    auto merged = wss::Query<Shard, WRec>::merge(results, nullptr);
+
+    ck_assert_int_eq(merged.size(), 2*k);
+    for (size_t i=0; i<merged.size(); i++) {
+        ck_assert_int_ge(merged[i].key, lower_key);
+        ck_assert_int_le(merged[i].key, upper_key);
+    }
+
+    gsl_rng_free(parms.rng);
+    delete shard;
+    delete buffer;
+}
+END_TEST
+
+
+START_TEST(t_alias_buffer_query_scan)
+{
+    size_t n=1000;
+    auto buffer = create_weighted_mbuffer<WRec>(n);
+
+    uint64_t lower_key = 0;
+    uint64_t upper_key = 5;
+
+    size_t k = 1000;
+
+    size_t cnt[3] = {0};
+    wss:Parms<WRec> parms = {k};
+    parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
+
+    size_t total_samples = 0;
+
+    for (size_t i=0; i<1000; i++) {
+        auto state = wss::Query<Shard, WRec, false>::get_buffer_query_state(buffer, &parms);
+        ((wss::BufferState<WRec> *) state)->sample_size = k;
+        auto result = wss::Query<Shard, WRec, false>::buffer_query(buffer, state, &parms);
+        total_samples += result.size();
+
+        for (size_t j=0; j<result.size(); j++) {
+            cnt[result[j].rec.key - 1]++;
+        }
+
+        wss::Query<Shard, WRec, false>::delete_buffer_query_state(state);
+    }
+
+    ck_assert(roughly_equal(cnt[0], (double) total_samples/4.0, total_samples, .05));
+    ck_assert(roughly_equal(cnt[1], (double) total_samples/4.0, total_samples, .05));
+    ck_assert(roughly_equal(cnt[2], (double) total_samples/2.0, total_samples, .05));
+
+    gsl_rng_free(parms.rng);
+    delete buffer;
+}
+END_TEST
+
+
+START_TEST(t_alias_buffer_query_rejection)
+{
+    size_t n=1000;
+    auto buffer = create_weighted_mbuffer<WRec>(n);
+
+    uint64_t lower_key = 0;
+    uint64_t upper_key = 5;
+
+    size_t k = 1000;
+
+    size_t cnt[3] = {0};
+    wss:Parms<WRec> parms = {k};
+    parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
+
+    size_t total_samples = 0;
+
+    for (size_t i=0; i<1000; i++) {
+        auto state = wss::Query<Shard, WRec>::get_buffer_query_state(buffer, &parms);
+        ((wss::BufferState<WRec> *) state)->sample_size = k;
+        auto result = wss::Query<Shard, WRec>::buffer_query(buffer, state, &parms);
+
+        total_samples += result.size();
+
+        for (size_t j=0; j<result.size(); j++) {
+            cnt[result[j].rec.key - 1]++;
+        }
+
+        wss::Query<Shard, WRec>::delete_buffer_query_state(state);
+    }
+
+    ck_assert(roughly_equal(cnt[0], (double) total_samples/4.0, total_samples, .1));
+    ck_assert(roughly_equal(cnt[1], (double) total_samples/4.0, total_samples, .1));
+    ck_assert(roughly_equal(cnt[2], (double) total_samples/2.0, total_samples, .1));
+
+    gsl_rng_free(parms.rng);
+    delete buffer;
+}
+END_TEST
+
+
+Suite *unit_testing()
+{
+    Suite *unit = suite_create("Alias Shard Unit Testing");
+
+    TCase *create = tcase_create("de::Alias constructor Testing");
+    tcase_add_test(create, t_mbuffer_init);
+    tcase_add_test(create, t_alias_init);
+    tcase_set_timeout(create, 100);
+    suite_add_tcase(unit, create);
+
+
+    TCase *tombstone = tcase_create("de:Alias::tombstone cancellation Testing");
+    tcase_add_test(tombstone, t_full_cancelation);
+    suite_add_tcase(unit, tombstone);
+
+
+    TCase *lookup = tcase_create("de:Alias:point_lookup Testing");
+    tcase_add_test(lookup, t_point_lookup);
+    tcase_add_test(lookup, t_point_lookup_miss);
+    suite_add_tcase(unit, lookup);
+
+
+
+    TCase *sampling = tcase_create("de:Alias::AliasQuery Testing");
+    tcase_add_test(sampling, t_alias_query);
+    tcase_add_test(sampling, t_alias_query_merge);
+    tcase_add_test(sampling, t_alias_buffer_query_rejection);
+    tcase_add_test(sampling, t_alias_buffer_query_scan);
+    suite_add_tcase(unit, sampling);
+
+    return unit;
+}
+
+
+int shard_unit_tests()
+{
+    int failed = 0;
+    Suite *unit = unit_testing();
+    SRunner *unit_shardner = srunner_create(unit);
+
+    srunner_run_all(unit_shardner, CK_NORMAL);
+    failed = srunner_ntests_failed(unit_shardner);
+    srunner_free(unit_shardner);
+
+    return failed;
+}
+
+
+int main() 
+{
+    int unit_failed = shard_unit_tests();
+
+    return (unit_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/tests/memisam_tests.cpp b/tests/memisam_tests.cpp
index 0ae97dc..d3b8087 100644
--- a/tests/memisam_tests.cpp
+++ b/tests/memisam_tests.cpp
@@ -1,7 +1,7 @@
 /*
- * tests/irs_tests.cpp
+ * tests/isam_tests.cpp
  *
- * Unit tests for MemISAM (Augmented B+Tree) shard
+ * Unit tests for ISAM Tree shard
  *
  * Copyright (C) 2023 Douglas Rumbaugh <drumbaugh@psu.edu> 
  *                    Dong Xie <dongx@psu.edu>
@@ -10,14 +10,15 @@
  *
  */
 
-#include "shard/MemISAM.h"
+#include "shard/ISAMTree.h"
+#include "query/irs.h"
 #include "testing.h"
 
 #include <check.h>
 
 using namespace de;
 
-typedef MemISAM<Rec> Shard;
+typedef ISAMTree<Rec> Shard;
 
 START_TEST(t_mbuffer_init)
 {
@@ -181,15 +182,15 @@ START_TEST(t_irs_query)
     size_t k = 100;
 
     size_t cnt[3] = {0};
-    irs_query_parms<Rec> parms = {lower_key, upper_key, k};
+    irs::Parms<Rec> parms = {lower_key, upper_key, k};
     parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     size_t total_samples = 0;
 
     for (size_t i=0; i<1000; i++) {
-        auto state = IRSQuery<Rec, false>::get_query_state(&isam, &parms);
-        ((IRSState<WRec> *) state)->sample_size = k;
-        auto result = IRSQuery<Rec, false>::query(&isam, state, &parms);
+        auto state = irs::Query<Shard, Rec, false>::get_query_state(&isam, &parms);
+        ((irs::State<WRec> *) state)->sample_size = k;
+        auto result = irs::Query<Shard, Rec, false>::query(&isam, state, &parms);
 
         ck_assert_int_eq(result.size(), k);
 
@@ -198,7 +199,7 @@ START_TEST(t_irs_query)
             ck_assert_int_ge(rec.rec.key, lower_key);
         }
 
-        IRSQuery<Rec, false>::delete_query_state(state);
+        irs::Query<Shard, Rec, false>::delete_query_state(state);
     }
 
     gsl_rng_free(parms.rng);
@@ -220,25 +221,25 @@ START_TEST(t_irs_query_merge)
     size_t k = 1000;
 
     size_t cnt[3] = {0};
-    irs_query_parms<Rec> parms = {lower_key, upper_key, k};
+    irs::Parms<Rec> parms = {lower_key, upper_key, k};
     parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     std::vector<std::vector<de::Wrapped<Rec>>> results(2);
 
     for (size_t i=0; i<1000; i++) {
-        auto state1 = IRSQuery<Rec>::get_query_state(&shard, &parms);
-        ((IRSState<WRec> *) state1)->sample_size = k;
-        results[0] = IRSQuery<Rec>::query(&shard, state1, &parms);
+        auto state1 = irs::Query<Shard, Rec>::get_query_state(&shard, &parms);
+        ((irs::State<WRec> *) state1)->sample_size = k;
+        results[0] = irs::Query<Shard, Rec>::query(&shard, state1, &parms);
 
-        auto state2 = IRSQuery<Rec>::get_query_state(&shard, &parms);
-        ((IRSState<WRec> *) state2)->sample_size = k;
-        results[1] = IRSQuery<Rec>::query(&shard, state2, &parms);
+        auto state2 = irs::Query<Shard, Rec>::get_query_state(&shard, &parms);
+        ((irs::State<WRec> *) state2)->sample_size = k;
+        results[1] = irs::Query<Shard, Rec>::query(&shard, state2, &parms);
 
-        IRSQuery<Rec>::delete_query_state(state1);
-        IRSQuery<Rec>::delete_query_state(state2);
+        irs::Query<Shard, Rec>::delete_query_state(state1);
+        irs::Query<Shard, Rec>::delete_query_state(state2);
     }
 
-    auto merged = IRSQuery<Rec>::merge(results, nullptr);
+    auto merged = irs::Query<Shard, Rec>::merge(results, nullptr);
 
     ck_assert_int_eq(merged.size(), 2*k);
     for (size_t i=0; i<merged.size(); i++) {
@@ -263,15 +264,15 @@ START_TEST(t_irs_buffer_query_scan)
     size_t k = 100;
 
     size_t cnt[3] = {0};
-    irs_query_parms<Rec> parms = {lower_key, upper_key, k};
+    irs::Parms<Rec> parms = {lower_key, upper_key, k};
     parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     size_t total_samples = 0;
 
     for (size_t i=0; i<1000; i++) {
-        auto state = IRSQuery<Rec, false>::get_buffer_query_state(buffer, &parms);
-        ((IRSBufferState<WRec> *) state)->sample_size = k;
-        auto result = IRSQuery<Rec, false>::buffer_query(buffer, state, &parms);
+        auto state = irs::Query<Shard, Rec, false>::get_buffer_query_state(buffer, &parms);
+        ((irs::BufferState<WRec> *) state)->sample_size = k;
+        auto result = irs::Query<Shard, Rec, false>::buffer_query(buffer, state, &parms);
 
         ck_assert_int_eq(result.size(), k);
 
@@ -280,7 +281,7 @@ START_TEST(t_irs_buffer_query_scan)
             ck_assert_int_ge(rec.rec.key, lower_key);
         }
 
-        IRSQuery<Rec, false>::delete_buffer_query_state(state);
+        irs::Query<Shard, Rec, false>::delete_buffer_query_state(state);
     }
 
     gsl_rng_free(parms.rng);
@@ -300,15 +301,15 @@ START_TEST(t_irs_buffer_query_rejection)
     size_t k = 10000;
 
     size_t cnt[3] = {0};
-    irs_query_parms<Rec> parms = {lower_key, upper_key, k};
+    irs::Parms<Rec> parms = {lower_key, upper_key, k};
     parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     size_t total_samples = 0;
 
     for (size_t i=0; i<1000; i++) {
-        auto state = IRSQuery<Rec>::get_buffer_query_state(buffer, &parms);
-        ((IRSBufferState<WRec> *) state)->sample_size = k;
-        auto result = IRSQuery<Rec>::buffer_query(buffer, state, &parms);
+        auto state = irs::Query<Shard, Rec>::get_buffer_query_state(buffer, &parms);
+        ((irs::BufferState<WRec> *) state)->sample_size = k;
+        auto result = irs::Query<Shard, Rec>::buffer_query(buffer, state, &parms);
 
         ck_assert_int_gt(result.size(), 0);
         ck_assert_int_le(result.size(), k);
@@ -318,7 +319,7 @@ START_TEST(t_irs_buffer_query_rejection)
             ck_assert_int_ge(rec.rec.key, lower_key);
         }
 
-        IRSQuery<Rec>::delete_buffer_query_state(state);
+        irs::Query<Shard, Rec>::delete_buffer_query_state(state);
     }
 
     gsl_rng_free(parms.rng);
@@ -329,27 +330,27 @@ END_TEST
 
 Suite *unit_testing()
 {
-    Suite *unit = suite_create("MemISAM Shard Unit Testing");
+    Suite *unit = suite_create("ISAMTree Shard Unit Testing");
 
-    TCase *create = tcase_create("de::MemISAM constructor Testing");
+    TCase *create = tcase_create("de::ISAMTree constructor Testing");
     tcase_add_test(create, t_mbuffer_init);
     tcase_add_test(create, t_irs_init);
     tcase_set_timeout(create, 100);
     suite_add_tcase(unit, create);
 
 
-    TCase *tombstone = tcase_create("de:MemISAM::tombstone cancellation Testing");
+    TCase *tombstone = tcase_create("de:ISAMTree::tombstone cancellation Testing");
     tcase_add_test(tombstone, t_full_cancelation);
     suite_add_tcase(unit, tombstone);
 
 
-    TCase *lookup = tcase_create("de:MemISAM:point_lookup Testing");
+    TCase *lookup = tcase_create("de:ISAMTree:point_lookup Testing");
     tcase_add_test(lookup, t_point_lookup);
     tcase_add_test(lookup, t_point_lookup_miss);
     suite_add_tcase(unit, lookup);
 
 
-    TCase *sampling = tcase_create("de:MemISAM::MemISAMQuery Testing");
+    TCase *sampling = tcase_create("de:ISAMTree::ISAMTreeQuery Testing");
     tcase_add_test(sampling, t_irs_query);
     tcase_add_test(sampling, t_irs_query_merge);
     tcase_add_test(sampling, t_irs_buffer_query_rejection);
diff --git a/tests/pgm_tests.cpp b/tests/pgm_tests.cpp
index 0552417..1565384 100644
--- a/tests/pgm_tests.cpp
+++ b/tests/pgm_tests.cpp
@@ -11,6 +11,7 @@
  */
 
 #include "shard/PGM.h"
+#include "query/rangequery.h"
 #include "testing.h"
 
 #include <check.h>
@@ -144,13 +145,13 @@ START_TEST(t_range_query)
     auto buffer = create_sequential_mbuffer<Rec>(100, 1000);
     auto shard = Shard(buffer);
 
-    pgm_range_query_parms<Rec> parms;
+    rq::Parms<Rec> parms;
     parms.lower_bound = 300;
     parms.upper_bound = 500;
 
-    auto state = PGMRangeQuery<Rec>::get_query_state(&shard, &parms);
-    auto result = PGMRangeQuery<Rec>::query(&shard, state, &parms);
-    PGMRangeQuery<Rec>::delete_query_state(state);
+    auto state = rq::Query<Shard, Rec>::get_query_state(&shard, &parms);
+    auto result = rq::Query<Shard, Rec>::query(&shard, state, &parms);
+    rq::Query<Shard, Rec>::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++) {
@@ -167,13 +168,13 @@ START_TEST(t_buffer_range_query)
 {
     auto buffer = create_sequential_mbuffer<Rec>(100, 1000);
 
-    pgm_range_query_parms<Rec> parms;
+    rq::Parms<Rec> parms;
     parms.lower_bound = 300;
     parms.upper_bound = 500;
 
-    auto state = PGMRangeQuery<Rec>::get_buffer_query_state(buffer, &parms);
-    auto result = PGMRangeQuery<Rec>::buffer_query(buffer, state, &parms);
-    PGMRangeQuery<Rec>::delete_buffer_query_state(state);
+    auto state = rq::Query<Shard, Rec>::get_buffer_query_state(buffer, &parms);
+    auto result = rq::Query<Shard, Rec>::buffer_query(buffer, state, &parms);
+    rq::Query<Shard, Rec>::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++) {
@@ -194,21 +195,21 @@ START_TEST(t_range_query_merge)
     auto shard1 = Shard(buffer1);
     auto shard2 = Shard(buffer2);
 
-    pgm_range_query_parms<Rec> parms;
+    rq::Parms<Rec> parms;
     parms.lower_bound = 150;
     parms.upper_bound = 500;
 
     size_t result_size = parms.upper_bound - parms.lower_bound + 1 - 200;
 
-    auto state1 = PGMRangeQuery<Rec>::get_query_state(&shard1, &parms);
-    auto state2 = PGMRangeQuery<Rec>::get_query_state(&shard2, &parms);
+    auto state1 = rq::Query<Shard, Rec>::get_query_state(&shard1, &parms);
+    auto state2 = rq::Query<Shard, Rec>::get_query_state(&shard2, &parms);
 
     std::vector<std::vector<de::Wrapped<Rec>>> results(2);
-    results[0] = PGMRangeQuery<Rec>::query(&shard1, state1, &parms);
-    results[1] = PGMRangeQuery<Rec>::query(&shard2, state2, &parms);
+    results[0] = rq::Query<Shard, Rec>::query(&shard1, state1, &parms);
+    results[1] = rq::Query<Shard, Rec>::query(&shard2, state2, &parms);
 
-    PGMRangeQuery<Rec>::delete_query_state(state1);
-    PGMRangeQuery<Rec>::delete_query_state(state2);
+    rq::Query<Shard, Rec>::delete_query_state(state1);
+    rq::Query<Shard, Rec>::delete_query_state(state2);
 
     ck_assert_int_eq(results[0].size() + results[1].size(), result_size);
 
@@ -221,7 +222,7 @@ START_TEST(t_range_query_merge)
         }
     }
 
-    auto result = PGMRangeQuery<Rec>::merge(proc_results, nullptr);
+    auto result = rq::Query<Shard, Rec>::merge(proc_results, nullptr);
     std::sort(result.begin(), result.end());
 
     ck_assert_int_eq(result.size(), result_size);
diff --git a/tests/triespline_tests.cpp b/tests/triespline_tests.cpp
index 6f63961..101f143 100644
--- a/tests/triespline_tests.cpp
+++ b/tests/triespline_tests.cpp
@@ -13,6 +13,7 @@
 #include <functional>
 
 #include "shard/TrieSpline.h"
+#include "query/rangequery.h"
 #include "testing.h"
 
 #include <check.h>
@@ -176,13 +177,13 @@ START_TEST(t_range_query)
     auto buffer = create_sequential_mbuffer<Rec>(100, 1000);
     auto shard = Shard(buffer);
 
-    ts_range_query_parms<Rec> parms;
+    rq::Parms<Rec> parms;
     parms.lower_bound = 300;
     parms.upper_bound = 500;
 
-    auto state = TrieSplineRangeQuery<Rec>::get_query_state(&shard, &parms);
-    auto result = TrieSplineRangeQuery<Rec>::query(&shard, state, &parms);
-    TrieSplineRangeQuery<Rec>::delete_query_state(state);
+    auto state = rq::Query<Shard, Rec>::get_query_state(&shard, &parms);
+    auto result = rq::Query<Shard, Rec>::query(&shard, state, &parms);
+    rq::Query<Shard, Rec>::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++) {
@@ -199,13 +200,13 @@ START_TEST(t_buffer_range_query)
 {
     auto buffer = create_sequential_mbuffer<Rec>(100, 1000);
 
-    ts_range_query_parms<Rec> parms;
+    rq::Parms<Rec> parms;
     parms.lower_bound = 300;
     parms.upper_bound = 500;
 
-    auto state = TrieSplineRangeQuery<Rec>::get_buffer_query_state(buffer, &parms);
-    auto result = TrieSplineRangeQuery<Rec>::buffer_query(buffer, state, &parms);
-    TrieSplineRangeQuery<Rec>::delete_buffer_query_state(state);
+    auto state = rq::Query<Shard, Rec>::get_buffer_query_state(buffer, &parms);
+    auto result = rq::Query<Shard, Rec>::buffer_query(buffer, state, &parms);
+    rq::Query<Shard, Rec>::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++) {
diff --git a/tests/wss_tests.cpp b/tests/wss_tests.cpp
deleted file mode 100644
index cdc8001..0000000
--- a/tests/wss_tests.cpp
+++ /dev/null
@@ -1,390 +0,0 @@
-/*
- * tests/wss_tests.cpp
- *
- * Unit tests for WSS (Augmented B+Tree) shard
- *
- * Copyright (C) 2023 Douglas Rumbaugh <drumbaugh@psu.edu> 
- *                    Dong Xie <dongx@psu.edu>
- *
- * All rights reserved. Published under the Modified BSD License.
- *
- */
-
-#include "shard/WSS.h"
-#include "testing.h"
-
-#include <check.h>
-
-using namespace de;
-
-typedef WSS<WRec> Shard;
-
-START_TEST(t_mbuffer_init)
-{
-    auto buffer = new MutableBuffer<WRec>(1024, 1024);
-    for (uint64_t i = 512; i > 0; i--) {
-        uint32_t v = i;
-        buffer->append({i,v, 1});
-    }
-    
-    for (uint64_t i = 1; i <= 256; ++i) {
-        uint32_t v = i;
-        buffer->append({i, v, 1}, true);
-    }
-
-    for (uint64_t i = 257; i <= 512; ++i) {
-        uint32_t v = i + 1;
-        buffer->append({i, v, 1});
-    }
-
-    Shard* shard = new Shard(buffer);
-    ck_assert_uint_eq(shard->get_record_count(), 512);
-
-    delete buffer;
-    delete shard;
-}
-
-
-START_TEST(t_wss_init)
-{
-    size_t n = 512;
-    auto mbuffer1 = create_test_mbuffer<WRec>(n);
-    auto mbuffer2 = create_test_mbuffer<WRec>(n);
-    auto mbuffer3 = create_test_mbuffer<WRec>(n);
-
-    auto shard1 = new Shard(mbuffer1);
-    auto shard2 = new Shard(mbuffer2);
-    auto shard3 = new Shard(mbuffer3);
-
-    Shard* shards[3] = {shard1, shard2, shard3};
-    auto shard4 = new Shard(shards, 3);
-
-    ck_assert_int_eq(shard4->get_record_count(), n * 3);
-    ck_assert_int_eq(shard4->get_tombstone_count(), 0);
-
-    size_t total_cnt = 0;
-    size_t shard1_idx = 0;
-    size_t shard2_idx = 0;
-    size_t shard3_idx = 0;
-
-    for (size_t i = 0; i < shard4->get_record_count(); ++i) {
-        auto rec1 = shard1->get_record_at(shard1_idx);
-        auto rec2 = shard2->get_record_at(shard2_idx);
-        auto rec3 = shard3->get_record_at(shard3_idx);
-
-        auto cur_rec = shard4->get_record_at(i);
-
-        if (shard1_idx < n && cur_rec->rec == rec1->rec) {
-            ++shard1_idx;
-        } else if (shard2_idx < n && cur_rec->rec == rec2->rec) {
-            ++shard2_idx;
-        } else if (shard3_idx < n && cur_rec->rec == rec3->rec) {
-            ++shard3_idx;
-        } else {
-           assert(false);
-        }
-    }
-
-    delete mbuffer1;
-    delete mbuffer2;
-    delete mbuffer3;
-
-    delete shard1;
-    delete shard2;
-    delete shard3;
-    delete shard4;
-}
-
-
-START_TEST(t_point_lookup) 
-{
-    size_t n = 10000;
-
-    auto buffer = create_double_seq_mbuffer<WRec>(n, false);
-    auto wss = Shard(buffer);
-
-    for (size_t i=0; i<n; i++) {
-        WRec r;
-        auto rec = (buffer->get_data() + i);
-        r.key = rec->rec.key;
-        r.value = rec->rec.value;
-
-        auto result = wss.point_lookup(r);
-        ck_assert_ptr_nonnull(result);
-        ck_assert_int_eq(result->rec.key, r.key);
-        ck_assert_int_eq(result->rec.value, r.value);
-    }
-
-    delete buffer;
-}
-END_TEST
-
-
-START_TEST(t_point_lookup_miss) 
-{
-    size_t n = 10000;
-
-    auto buffer = create_double_seq_mbuffer<WRec>(n, false);
-    auto wss = Shard(buffer);
-
-    for (size_t i=n + 100; i<2*n; i++) {
-        WRec r;
-        r.key = i;
-        r.value = i;
-
-        auto result = wss.point_lookup(r);
-        ck_assert_ptr_null(result);
-    }
-
-    delete buffer;
-}
-
-START_TEST(t_full_cancelation)
-{
-    size_t n = 100;
-    auto buffer = create_double_seq_mbuffer<WRec>(n, false);
-    auto buffer_ts = create_double_seq_mbuffer<WRec>(n, true);
-
-    Shard* shard = new Shard(buffer);
-    Shard* shard_ts = new Shard(buffer_ts);
-
-    ck_assert_int_eq(shard->get_record_count(), n);
-    ck_assert_int_eq(shard->get_tombstone_count(), 0);
-    ck_assert_int_eq(shard_ts->get_record_count(), n);
-    ck_assert_int_eq(shard_ts->get_tombstone_count(), n);
-
-    Shard* shards[] = {shard, shard_ts};
-
-    Shard* merged = new Shard(shards, 2);
-
-    ck_assert_int_eq(merged->get_tombstone_count(), 0);
-    ck_assert_int_eq(merged->get_record_count(), 0);
-
-    delete buffer;
-    delete buffer_ts;
-    delete shard;
-    delete shard_ts;
-    delete merged;
-}
-END_TEST
-
-
-START_TEST(t_wss_query)
-{
-    size_t n=1000;
-    auto buffer = create_weighted_mbuffer<WRec>(n);
-
-    Shard* shard = new Shard(buffer);
-
-    size_t k = 1000;
-
-    size_t cnt[3] = {0};
-    wss_query_parms<WRec> parms = {k};
-    parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
-
-    size_t total_samples = 0;
-
-    for (size_t i=0; i<1000; i++) {
-        auto state = WSSQuery<WRec>::get_query_state(shard, &parms);
-        ((WSSState<WRec> *) state)->sample_size = k;
-        auto result = WSSQuery<WRec>::query(shard, state, &parms);
-
-        total_samples += result.size();
-
-        for (size_t j=0; j<result.size(); j++) {
-            cnt[result[j].rec.key - 1]++;
-        }
-
-        WSSQuery<WRec>::delete_query_state(state);
-    }
-
-    ck_assert(roughly_equal(cnt[0], (double) total_samples/4.0, total_samples, .05));
-    ck_assert(roughly_equal(cnt[1], (double) total_samples/4.0, total_samples, .05));
-    ck_assert(roughly_equal(cnt[2], (double) total_samples/2.0, total_samples, .05));
-
-    gsl_rng_free(parms.rng);
-    delete shard;
-    delete buffer;
-}
-END_TEST
-
-
-START_TEST(t_wss_query_merge)
-{
-    size_t n=1000;
-    auto buffer = create_weighted_mbuffer<WRec>(n);
-
-    Shard* shard = new Shard(buffer);
-
-    uint64_t lower_key = 0;
-    uint64_t upper_key = 5;
-
-    size_t k = 1000;
-
-    size_t cnt[3] = {0};
-    wss_query_parms<WRec> parms = {k};
-    parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
-
-    std::vector<std::vector<Wrapped<WRec>>> results(2);
-
-    for (size_t i=0; i<1000; i++) {
-        auto state1 = WSSQuery<WRec>::get_query_state(shard, &parms);
-        ((WSSState<WRec> *) state1)->sample_size = k;
-        results[0] = WSSQuery<WRec>::query(shard, state1, &parms);
-
-        auto state2 = WSSQuery<WRec>::get_query_state(shard, &parms);
-        ((WSSState<WRec> *) state2)->sample_size = k;
-        results[1] = WSSQuery<WRec>::query(shard, state2, &parms);
-
-        WSSQuery<WRec>::delete_query_state(state1);
-        WSSQuery<WRec>::delete_query_state(state2);
-    }
-
-    auto merged = WSSQuery<WRec>::merge(results, nullptr);
-
-    ck_assert_int_eq(merged.size(), 2*k);
-    for (size_t i=0; i<merged.size(); i++) {
-        ck_assert_int_ge(merged[i].key, lower_key);
-        ck_assert_int_le(merged[i].key, upper_key);
-    }
-
-    gsl_rng_free(parms.rng);
-    delete shard;
-    delete buffer;
-}
-END_TEST
-
-
-START_TEST(t_wss_buffer_query_scan)
-{
-    size_t n=1000;
-    auto buffer = create_weighted_mbuffer<WRec>(n);
-
-    uint64_t lower_key = 0;
-    uint64_t upper_key = 5;
-
-    size_t k = 1000;
-
-    size_t cnt[3] = {0};
-    wss_query_parms<WRec> parms = {k};
-    parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
-
-    size_t total_samples = 0;
-
-    for (size_t i=0; i<1000; i++) {
-        auto state = WSSQuery<WRec, false>::get_buffer_query_state(buffer, &parms);
-        ((WSSBufferState<WRec> *) state)->sample_size = k;
-        auto result = WSSQuery<WRec, false>::buffer_query(buffer, state, &parms);
-        total_samples += result.size();
-
-        for (size_t j=0; j<result.size(); j++) {
-            cnt[result[j].rec.key - 1]++;
-        }
-
-        WSSQuery<WRec, false>::delete_buffer_query_state(state);
-    }
-
-    ck_assert(roughly_equal(cnt[0], (double) total_samples/4.0, total_samples, .05));
-    ck_assert(roughly_equal(cnt[1], (double) total_samples/4.0, total_samples, .05));
-    ck_assert(roughly_equal(cnt[2], (double) total_samples/2.0, total_samples, .05));
-
-    gsl_rng_free(parms.rng);
-    delete buffer;
-}
-END_TEST
-
-
-START_TEST(t_wss_buffer_query_rejection)
-{
-    size_t n=1000;
-    auto buffer = create_weighted_mbuffer<WRec>(n);
-
-    uint64_t lower_key = 0;
-    uint64_t upper_key = 5;
-
-    size_t k = 1000;
-
-    size_t cnt[3] = {0};
-    wss_query_parms<WRec> parms = {k};
-    parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
-
-    size_t total_samples = 0;
-
-    for (size_t i=0; i<1000; i++) {
-        auto state = WSSQuery<WRec>::get_buffer_query_state(buffer, &parms);
-        ((WSSBufferState<WRec> *) state)->sample_size = k;
-        auto result = WSSQuery<WRec>::buffer_query(buffer, state, &parms);
-
-        total_samples += result.size();
-
-        for (size_t j=0; j<result.size(); j++) {
-            cnt[result[j].rec.key - 1]++;
-        }
-
-        WSSQuery<WRec>::delete_buffer_query_state(state);
-    }
-
-    ck_assert(roughly_equal(cnt[0], (double) total_samples/4.0, total_samples, .1));
-    ck_assert(roughly_equal(cnt[1], (double) total_samples/4.0, total_samples, .1));
-    ck_assert(roughly_equal(cnt[2], (double) total_samples/2.0, total_samples, .1));
-
-    gsl_rng_free(parms.rng);
-    delete buffer;
-}
-END_TEST
-
-
-Suite *unit_testing()
-{
-    Suite *unit = suite_create("WSS Shard Unit Testing");
-
-    TCase *create = tcase_create("de::WSS constructor Testing");
-    tcase_add_test(create, t_mbuffer_init);
-    tcase_add_test(create, t_wss_init);
-    tcase_set_timeout(create, 100);
-    suite_add_tcase(unit, create);
-
-
-    TCase *tombstone = tcase_create("de:WSS::tombstone cancellation Testing");
-    tcase_add_test(tombstone, t_full_cancelation);
-    suite_add_tcase(unit, tombstone);
-
-
-    TCase *lookup = tcase_create("de:WSS:point_lookup Testing");
-    tcase_add_test(lookup, t_point_lookup);
-    tcase_add_test(lookup, t_point_lookup_miss);
-    suite_add_tcase(unit, lookup);
-
-
-
-    TCase *sampling = tcase_create("de:WSS::WSSQuery Testing");
-    tcase_add_test(sampling, t_wss_query);
-    tcase_add_test(sampling, t_wss_query_merge);
-    tcase_add_test(sampling, t_wss_buffer_query_rejection);
-    tcase_add_test(sampling, t_wss_buffer_query_scan);
-    suite_add_tcase(unit, sampling);
-
-    return unit;
-}
-
-
-int shard_unit_tests()
-{
-    int failed = 0;
-    Suite *unit = unit_testing();
-    SRunner *unit_shardner = srunner_create(unit);
-
-    srunner_run_all(unit_shardner, CK_NORMAL);
-    failed = srunner_ntests_failed(unit_shardner);
-    srunner_free(unit_shardner);
-
-    return failed;
-}
-
-
-int main() 
-{
-    int unit_failed = shard_unit_tests();
-
-    return (unit_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
-}
-- 
cgit v1.2.3


From a2fe4b1616a1b2318f70e842382818ee44aea9e6 Mon Sep 17 00:00:00 2001
From: Douglas Rumbaugh <dbr4@psu.edu>
Date: Tue, 7 Nov 2023 12:29:03 -0500
Subject: Alias shard fixes

---
 tests/alias_tests.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'tests')

diff --git a/tests/alias_tests.cpp b/tests/alias_tests.cpp
index b9e678b..c4a302d 100644
--- a/tests/alias_tests.cpp
+++ b/tests/alias_tests.cpp
@@ -180,7 +180,7 @@ START_TEST(t_alias_query)
     size_t k = 1000;
 
     size_t cnt[3] = {0};
-    wss:Parms<WRec> parms = {k};
+    wss::Parms<WRec> parms = {k};
     parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     size_t total_samples = 0;
@@ -223,7 +223,7 @@ START_TEST(t_alias_query_merge)
     size_t k = 1000;
 
     size_t cnt[3] = {0};
-    wss:Parms<WRec> parms = {k};
+    wss::Parms<WRec> parms = {k};
     parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     std::vector<std::vector<Wrapped<WRec>>> results(2);
@@ -267,7 +267,7 @@ START_TEST(t_alias_buffer_query_scan)
     size_t k = 1000;
 
     size_t cnt[3] = {0};
-    wss:Parms<WRec> parms = {k};
+    wss::Parms<WRec> parms = {k};
     parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     size_t total_samples = 0;
@@ -306,7 +306,7 @@ START_TEST(t_alias_buffer_query_rejection)
     size_t k = 1000;
 
     size_t cnt[3] = {0};
-    wss:Parms<WRec> parms = {k};
+    wss::Parms<WRec> parms = {k};
     parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     size_t total_samples = 0;
-- 
cgit v1.2.3


From 9e1c1b1b930031896851b1ed4a15152508327d73 Mon Sep 17 00:00:00 2001
From: Douglas Rumbaugh <dbr4@psu.edu>
Date: Tue, 7 Nov 2023 13:35:54 -0500
Subject: Converted WIRS to the new interface

---
 tests/augbtree_tests.cpp | 395 +++++++++++++++++++++++++++++++++++++++++++++++
 tests/wirs_tests.cpp     | 394 ----------------------------------------------
 2 files changed, 395 insertions(+), 394 deletions(-)
 create mode 100644 tests/augbtree_tests.cpp
 delete mode 100644 tests/wirs_tests.cpp

(limited to 'tests')

diff --git a/tests/augbtree_tests.cpp b/tests/augbtree_tests.cpp
new file mode 100644
index 0000000..878af82
--- /dev/null
+++ b/tests/augbtree_tests.cpp
@@ -0,0 +1,395 @@
+/*
+ * tests/wirs_tests.cpp
+ *
+ * Unit tests for AugBTree (Augmented B+Tree) shard
+ *
+ * Copyright (C) 2023 Douglas Rumbaugh <drumbaugh@psu.edu> 
+ *                    Dong Xie <dongx@psu.edu>
+ *
+ * All rights reserved. Published under the Modified BSD License.
+ *
+ */
+
+#include "shard/AugBTree.h"
+#include "query/wirs.h"
+#include "testing.h"
+
+#include <check.h>
+
+using namespace de;
+
+typedef AugBTree<WRec> Shard;
+
+START_TEST(t_mbuffer_init)
+{
+    auto buffer = new MutableBuffer<WRec>(1024, 1024);
+    for (uint64_t i = 512; i > 0; i--) {
+        uint32_t v = i;
+        buffer->append({i,v, 1});
+    }
+    
+    for (uint64_t i = 1; i <= 256; ++i) {
+        uint32_t v = i;
+        buffer->append({i, v, 1}, true);
+    }
+
+    for (uint64_t i = 257; i <= 512; ++i) {
+        uint32_t v = i + 1;
+        buffer->append({i, v, 1});
+    }
+
+    Shard* shard = new Shard(buffer);
+    ck_assert_uint_eq(shard->get_record_count(), 512);
+
+    delete buffer;
+    delete shard;
+}
+
+
+START_TEST(t_wirs_init)
+{
+    size_t n = 512;
+    auto mbuffer1 = create_test_mbuffer<WRec>(n);
+    auto mbuffer2 = create_test_mbuffer<WRec>(n);
+    auto mbuffer3 = create_test_mbuffer<WRec>(n);
+
+    auto shard1 = new Shard(mbuffer1);
+    auto shard2 = new Shard(mbuffer2);
+    auto shard3 = new Shard(mbuffer3);
+
+    Shard* shards[3] = {shard1, shard2, shard3};
+    auto shard4 = new Shard(shards, 3);
+
+    ck_assert_int_eq(shard4->get_record_count(), n * 3);
+    ck_assert_int_eq(shard4->get_tombstone_count(), 0);
+
+    size_t total_cnt = 0;
+    size_t shard1_idx = 0;
+    size_t shard2_idx = 0;
+    size_t shard3_idx = 0;
+
+    for (size_t i = 0; i < shard4->get_record_count(); ++i) {
+        auto rec1 = shard1->get_record_at(shard1_idx);
+        auto rec2 = shard2->get_record_at(shard2_idx);
+        auto rec3 = shard3->get_record_at(shard3_idx);
+
+        auto cur_rec = shard4->get_record_at(i);
+
+        if (shard1_idx < n && cur_rec->rec == rec1->rec) {
+            ++shard1_idx;
+        } else if (shard2_idx < n && cur_rec->rec == rec2->rec) {
+            ++shard2_idx;
+        } else if (shard3_idx < n && cur_rec->rec == rec3->rec) {
+            ++shard3_idx;
+        } else {
+           assert(false);
+        }
+    }
+
+    delete mbuffer1;
+    delete mbuffer2;
+    delete mbuffer3;
+
+    delete shard1;
+    delete shard2;
+    delete shard3;
+    delete shard4;
+}
+
+
+START_TEST(t_point_lookup) 
+{
+    size_t n = 10000;
+
+    auto buffer = create_double_seq_mbuffer<WRec>(n, false);
+    auto wirs = Shard(buffer);
+
+    for (size_t i=0; i<n; i++) {
+        WRec r;
+        auto rec = (buffer->get_data() + i);
+        r.key = rec->rec.key;
+        r.value = rec->rec.value;
+
+        auto result = wirs.point_lookup(r);
+        ck_assert_ptr_nonnull(result);
+        ck_assert_int_eq(result->rec.key, r.key);
+        ck_assert_int_eq(result->rec.value, r.value);
+    }
+
+    delete buffer;
+}
+END_TEST
+
+
+START_TEST(t_point_lookup_miss) 
+{
+    size_t n = 10000;
+
+    auto buffer = create_double_seq_mbuffer<WRec>(n, false);
+    auto wirs = Shard(buffer);
+
+    for (size_t i=n + 100; i<2*n; i++) {
+        WRec r;
+        r.key = i;
+        r.value = i;
+
+        auto result = wirs.point_lookup(r);
+        ck_assert_ptr_null(result);
+    }
+
+    delete buffer;
+}
+
+
+START_TEST(t_full_cancelation)
+{
+    size_t n = 100;
+    auto buffer = create_double_seq_mbuffer<WRec>(n, false);
+    auto buffer_ts = create_double_seq_mbuffer<WRec>(n, true);
+
+    Shard* shard = new Shard(buffer);
+    Shard* shard_ts = new Shard(buffer_ts);
+
+    ck_assert_int_eq(shard->get_record_count(), n);
+    ck_assert_int_eq(shard->get_tombstone_count(), 0);
+    ck_assert_int_eq(shard_ts->get_record_count(), n);
+    ck_assert_int_eq(shard_ts->get_tombstone_count(), n);
+
+    Shard* shards[] = {shard, shard_ts};
+
+    Shard* merged = new Shard(shards, 2);
+
+    ck_assert_int_eq(merged->get_tombstone_count(), 0);
+    ck_assert_int_eq(merged->get_record_count(), 0);
+
+    delete buffer;
+    delete buffer_ts;
+    delete shard;
+    delete shard_ts;
+    delete merged;
+}
+END_TEST
+
+
+START_TEST(t_wirs_query)
+{
+    size_t n=1000;
+    auto buffer = create_weighted_mbuffer<WRec>(n);
+
+    Shard* shard = new Shard(buffer);
+
+    uint64_t lower_key = 0;
+    uint64_t upper_key = 5;
+
+    size_t k = 1000;
+
+    size_t cnt[3] = {0};
+    wirs::Parms<WRec> parms = {lower_key, upper_key, k};
+    parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
+
+    size_t total_samples = 0;
+
+    for (size_t i=0; i<1000; i++) {
+        auto state = wirs::Query<Shard, WRec>::get_query_state(shard, &parms);
+        ((wirs::State<WRec> *) state)->sample_size = k;
+        auto result = wirs::Query<Shard, WRec>::query(shard, state, &parms);
+
+        total_samples += result.size();
+
+        for (size_t j=0; j<result.size(); j++) {
+            cnt[result[j].rec.key - 1]++;
+        }
+
+        wirs::Query<Shard, WRec>::delete_query_state(state);
+    }
+
+    ck_assert(roughly_equal(cnt[0], (double) total_samples/4.0, total_samples, .05));
+    ck_assert(roughly_equal(cnt[1], (double) total_samples/4.0, total_samples, .05));
+    ck_assert(roughly_equal(cnt[2], (double) total_samples/2.0, total_samples, .05));
+
+    gsl_rng_free(parms.rng);
+    delete shard;
+    delete buffer;
+}
+END_TEST
+
+
+START_TEST(t_wirs_query_merge)
+{
+    size_t n=1000;
+    auto buffer = create_weighted_mbuffer<WRec>(n);
+
+    Shard* shard = new Shard(buffer);
+
+    uint64_t lower_key = 0;
+    uint64_t upper_key = 5;
+
+    size_t k = 1000;
+
+    size_t cnt[3] = {0};
+    wirs::Parms<WRec> parms = {lower_key, upper_key, k};
+    parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
+
+    std::vector<std::vector<Wrapped<WRec>>> results(2);
+
+    for (size_t i=0; i<1000; i++) {
+        auto state1 = wirs::Query<Shard, WRec>::get_query_state(shard, &parms);
+        ((wirs::State<WRec> *) state1)->sample_size = k;
+        results[0] = wirs::Query<Shard, WRec>::query(shard, state1, &parms);
+
+        auto state2 = wirs::Query<Shard, WRec>::get_query_state(shard, &parms);
+        ((wirs::State<WRec> *) state2)->sample_size = k;
+        results[1] = wirs::Query<Shard, WRec>::query(shard, state2, &parms);
+
+        wirs::Query<Shard, WRec>::delete_query_state(state1);
+        wirs::Query<Shard, WRec>::delete_query_state(state2);
+    }
+
+    auto merged = wirs::Query<Shard, WRec>::merge(results, nullptr);
+
+    ck_assert_int_eq(merged.size(), 2*k);
+    for (size_t i=0; i<merged.size(); i++) {
+        ck_assert_int_ge(merged[i].key, lower_key);
+        ck_assert_int_le(merged[i].key, upper_key);
+    }
+
+    gsl_rng_free(parms.rng);
+    delete shard;
+    delete buffer;
+}
+END_TEST
+
+
+START_TEST(t_wirs_buffer_query_scan)
+{
+    size_t n=1000;
+    auto buffer = create_weighted_mbuffer<WRec>(n);
+
+    uint64_t lower_key = 0;
+    uint64_t upper_key = 5;
+
+    size_t k = 1000;
+
+    size_t cnt[3] = {0};
+    wirs::Parms<WRec> parms = {lower_key, upper_key, k};
+    parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
+
+    size_t total_samples = 0;
+
+    for (size_t i=0; i<1000; i++) {
+        auto state = wirs::Query<Shard, WRec, false>::get_buffer_query_state(buffer, &parms);
+        ((wirs::BufferState<WRec> *) state)->sample_size = k;
+        auto result = wirs::Query<Shard, WRec, false>::buffer_query(buffer, state, &parms);
+
+        total_samples += result.size();
+
+        for (size_t j=0; j<result.size(); j++) {
+            cnt[result[j].rec.key - 1]++;
+        }
+
+        wirs::Query<Shard, WRec, false>::delete_buffer_query_state(state);
+    }
+
+    ck_assert(roughly_equal(cnt[0], (double) total_samples/4.0, total_samples, .05));
+    ck_assert(roughly_equal(cnt[1], (double) total_samples/4.0, total_samples, .05));
+    ck_assert(roughly_equal(cnt[2], (double) total_samples/2.0, total_samples, .05));
+
+    gsl_rng_free(parms.rng);
+    delete buffer;
+}
+END_TEST
+
+
+START_TEST(t_wirs_buffer_query_rejection)
+{
+    size_t n=1000;
+    auto buffer = create_weighted_mbuffer<WRec>(n);
+
+    uint64_t lower_key = 0;
+    uint64_t upper_key = 5;
+
+    size_t k = 1000;
+
+    size_t cnt[3] = {0};
+    wirs::Parms<WRec> parms = {lower_key, upper_key, k};
+    parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
+
+    size_t total_samples = 0;
+
+    for (size_t i=0; i<1000; i++) {
+        auto state = wirs::Query<Shard, WRec>::get_buffer_query_state(buffer, &parms);
+        ((wirs::BufferState<WRec> *) state)->sample_size = k;
+        auto result = wirs::Query<Shard, WRec>::buffer_query(buffer, state, &parms);
+
+        total_samples += result.size();
+
+        for (size_t j=0; j<result.size(); j++) {
+            cnt[result[j].rec.key - 1]++;
+        }
+
+        wirs::Query<Shard, WRec>::delete_buffer_query_state(state);
+    }
+
+    ck_assert(roughly_equal(cnt[0], (double) total_samples/4.0, total_samples, .05));
+    ck_assert(roughly_equal(cnt[1], (double) total_samples/4.0, total_samples, .05));
+    ck_assert(roughly_equal(cnt[2], (double) total_samples/2.0, total_samples, .05));
+
+    gsl_rng_free(parms.rng);
+    delete buffer;
+}
+END_TEST
+
+
+Suite *unit_testing()
+{
+    Suite *unit = suite_create("AugBTree Shard Unit Testing");
+
+    TCase *create = tcase_create("de::AugBTree constructor Testing");
+    tcase_add_test(create, t_mbuffer_init);
+    tcase_add_test(create, t_wirs_init);
+    tcase_set_timeout(create, 100);
+    suite_add_tcase(unit, create);
+
+
+    TCase *tombstone = tcase_create("de:AugBTree::tombstone cancellation Testing");
+    tcase_add_test(tombstone, t_full_cancelation);
+    suite_add_tcase(unit, tombstone);
+
+
+    TCase *lookup = tcase_create("de:AugBTree:point_lookup Testing");
+    tcase_add_test(lookup, t_point_lookup);
+    tcase_add_test(lookup, t_point_lookup_miss);
+    suite_add_tcase(unit, lookup);
+
+
+    TCase *sampling = tcase_create("de:AugBTree::AugBTreeQuery Testing");
+    tcase_add_test(sampling, t_wirs_query);
+    tcase_add_test(sampling, t_wirs_query_merge);
+    tcase_add_test(sampling, t_wirs_buffer_query_rejection);
+    tcase_add_test(sampling, t_wirs_buffer_query_scan);
+    suite_add_tcase(unit, sampling);
+
+    return unit;
+}
+
+
+int shard_unit_tests()
+{
+    int failed = 0;
+    Suite *unit = unit_testing();
+    SRunner *unit_shardner = srunner_create(unit);
+
+    srunner_run_all(unit_shardner, CK_NORMAL);
+    failed = srunner_ntests_failed(unit_shardner);
+    srunner_free(unit_shardner);
+
+    return failed;
+}
+
+
+int main() 
+{
+    int unit_failed = shard_unit_tests();
+
+    return (unit_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/tests/wirs_tests.cpp b/tests/wirs_tests.cpp
deleted file mode 100644
index a72f950..0000000
--- a/tests/wirs_tests.cpp
+++ /dev/null
@@ -1,394 +0,0 @@
-/*
- * tests/wirs_tests.cpp
- *
- * Unit tests for WIRS (Augmented B+Tree) shard
- *
- * Copyright (C) 2023 Douglas Rumbaugh <drumbaugh@psu.edu> 
- *                    Dong Xie <dongx@psu.edu>
- *
- * All rights reserved. Published under the Modified BSD License.
- *
- */
-
-#include "shard/WIRS.h"
-#include "testing.h"
-
-#include <check.h>
-
-using namespace de;
-
-typedef WIRS<WRec> Shard;
-
-START_TEST(t_mbuffer_init)
-{
-    auto buffer = new MutableBuffer<WRec>(1024, 1024);
-    for (uint64_t i = 512; i > 0; i--) {
-        uint32_t v = i;
-        buffer->append({i,v, 1});
-    }
-    
-    for (uint64_t i = 1; i <= 256; ++i) {
-        uint32_t v = i;
-        buffer->append({i, v, 1}, true);
-    }
-
-    for (uint64_t i = 257; i <= 512; ++i) {
-        uint32_t v = i + 1;
-        buffer->append({i, v, 1});
-    }
-
-    Shard* shard = new Shard(buffer);
-    ck_assert_uint_eq(shard->get_record_count(), 512);
-
-    delete buffer;
-    delete shard;
-}
-
-
-START_TEST(t_wirs_init)
-{
-    size_t n = 512;
-    auto mbuffer1 = create_test_mbuffer<WRec>(n);
-    auto mbuffer2 = create_test_mbuffer<WRec>(n);
-    auto mbuffer3 = create_test_mbuffer<WRec>(n);
-
-    auto shard1 = new Shard(mbuffer1);
-    auto shard2 = new Shard(mbuffer2);
-    auto shard3 = new Shard(mbuffer3);
-
-    Shard* shards[3] = {shard1, shard2, shard3};
-    auto shard4 = new Shard(shards, 3);
-
-    ck_assert_int_eq(shard4->get_record_count(), n * 3);
-    ck_assert_int_eq(shard4->get_tombstone_count(), 0);
-
-    size_t total_cnt = 0;
-    size_t shard1_idx = 0;
-    size_t shard2_idx = 0;
-    size_t shard3_idx = 0;
-
-    for (size_t i = 0; i < shard4->get_record_count(); ++i) {
-        auto rec1 = shard1->get_record_at(shard1_idx);
-        auto rec2 = shard2->get_record_at(shard2_idx);
-        auto rec3 = shard3->get_record_at(shard3_idx);
-
-        auto cur_rec = shard4->get_record_at(i);
-
-        if (shard1_idx < n && cur_rec->rec == rec1->rec) {
-            ++shard1_idx;
-        } else if (shard2_idx < n && cur_rec->rec == rec2->rec) {
-            ++shard2_idx;
-        } else if (shard3_idx < n && cur_rec->rec == rec3->rec) {
-            ++shard3_idx;
-        } else {
-           assert(false);
-        }
-    }
-
-    delete mbuffer1;
-    delete mbuffer2;
-    delete mbuffer3;
-
-    delete shard1;
-    delete shard2;
-    delete shard3;
-    delete shard4;
-}
-
-
-START_TEST(t_point_lookup) 
-{
-    size_t n = 10000;
-
-    auto buffer = create_double_seq_mbuffer<WRec>(n, false);
-    auto wirs = Shard(buffer);
-
-    for (size_t i=0; i<n; i++) {
-        WRec r;
-        auto rec = (buffer->get_data() + i);
-        r.key = rec->rec.key;
-        r.value = rec->rec.value;
-
-        auto result = wirs.point_lookup(r);
-        ck_assert_ptr_nonnull(result);
-        ck_assert_int_eq(result->rec.key, r.key);
-        ck_assert_int_eq(result->rec.value, r.value);
-    }
-
-    delete buffer;
-}
-END_TEST
-
-
-START_TEST(t_point_lookup_miss) 
-{
-    size_t n = 10000;
-
-    auto buffer = create_double_seq_mbuffer<WRec>(n, false);
-    auto wirs = Shard(buffer);
-
-    for (size_t i=n + 100; i<2*n; i++) {
-        WRec r;
-        r.key = i;
-        r.value = i;
-
-        auto result = wirs.point_lookup(r);
-        ck_assert_ptr_null(result);
-    }
-
-    delete buffer;
-}
-
-
-START_TEST(t_full_cancelation)
-{
-    size_t n = 100;
-    auto buffer = create_double_seq_mbuffer<WRec>(n, false);
-    auto buffer_ts = create_double_seq_mbuffer<WRec>(n, true);
-
-    Shard* shard = new Shard(buffer);
-    Shard* shard_ts = new Shard(buffer_ts);
-
-    ck_assert_int_eq(shard->get_record_count(), n);
-    ck_assert_int_eq(shard->get_tombstone_count(), 0);
-    ck_assert_int_eq(shard_ts->get_record_count(), n);
-    ck_assert_int_eq(shard_ts->get_tombstone_count(), n);
-
-    Shard* shards[] = {shard, shard_ts};
-
-    Shard* merged = new Shard(shards, 2);
-
-    ck_assert_int_eq(merged->get_tombstone_count(), 0);
-    ck_assert_int_eq(merged->get_record_count(), 0);
-
-    delete buffer;
-    delete buffer_ts;
-    delete shard;
-    delete shard_ts;
-    delete merged;
-}
-END_TEST
-
-
-START_TEST(t_wirs_query)
-{
-    size_t n=1000;
-    auto buffer = create_weighted_mbuffer<WRec>(n);
-
-    Shard* shard = new Shard(buffer);
-
-    uint64_t lower_key = 0;
-    uint64_t upper_key = 5;
-
-    size_t k = 1000;
-
-    size_t cnt[3] = {0};
-    wirs_query_parms<WRec> parms = {lower_key, upper_key, k};
-    parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
-
-    size_t total_samples = 0;
-
-    for (size_t i=0; i<1000; i++) {
-        auto state = WIRSQuery<WRec>::get_query_state(shard, &parms);
-        ((WIRSState<WRec> *) state)->sample_size = k;
-        auto result = WIRSQuery<WRec>::query(shard, state, &parms);
-
-        total_samples += result.size();
-
-        for (size_t j=0; j<result.size(); j++) {
-            cnt[result[j].rec.key - 1]++;
-        }
-
-        WIRSQuery<WRec>::delete_query_state(state);
-    }
-
-    ck_assert(roughly_equal(cnt[0], (double) total_samples/4.0, total_samples, .05));
-    ck_assert(roughly_equal(cnt[1], (double) total_samples/4.0, total_samples, .05));
-    ck_assert(roughly_equal(cnt[2], (double) total_samples/2.0, total_samples, .05));
-
-    gsl_rng_free(parms.rng);
-    delete shard;
-    delete buffer;
-}
-END_TEST
-
-
-START_TEST(t_wirs_query_merge)
-{
-    size_t n=1000;
-    auto buffer = create_weighted_mbuffer<WRec>(n);
-
-    Shard* shard = new Shard(buffer);
-
-    uint64_t lower_key = 0;
-    uint64_t upper_key = 5;
-
-    size_t k = 1000;
-
-    size_t cnt[3] = {0};
-    wirs_query_parms<WRec> parms = {lower_key, upper_key, k};
-    parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
-
-    std::vector<std::vector<Wrapped<WRec>>> results(2);
-
-    for (size_t i=0; i<1000; i++) {
-        auto state1 = WIRSQuery<WRec>::get_query_state(shard, &parms);
-        ((WIRSState<WRec> *) state1)->sample_size = k;
-        results[0] = WIRSQuery<WRec>::query(shard, state1, &parms);
-
-        auto state2 = WIRSQuery<WRec>::get_query_state(shard, &parms);
-        ((WIRSState<WRec> *) state2)->sample_size = k;
-        results[1] = WIRSQuery<WRec>::query(shard, state2, &parms);
-
-        WIRSQuery<WRec>::delete_query_state(state1);
-        WIRSQuery<WRec>::delete_query_state(state2);
-    }
-
-    auto merged = WIRSQuery<WRec>::merge(results, nullptr);
-
-    ck_assert_int_eq(merged.size(), 2*k);
-    for (size_t i=0; i<merged.size(); i++) {
-        ck_assert_int_ge(merged[i].key, lower_key);
-        ck_assert_int_le(merged[i].key, upper_key);
-    }
-
-    gsl_rng_free(parms.rng);
-    delete shard;
-    delete buffer;
-}
-END_TEST
-
-
-START_TEST(t_wirs_buffer_query_scan)
-{
-    size_t n=1000;
-    auto buffer = create_weighted_mbuffer<WRec>(n);
-
-    uint64_t lower_key = 0;
-    uint64_t upper_key = 5;
-
-    size_t k = 1000;
-
-    size_t cnt[3] = {0};
-    wirs_query_parms<WRec> parms = {lower_key, upper_key, k};
-    parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
-
-    size_t total_samples = 0;
-
-    for (size_t i=0; i<1000; i++) {
-        auto state = WIRSQuery<WRec, false>::get_buffer_query_state(buffer, &parms);
-        ((WIRSBufferState<WRec> *) state)->sample_size = k;
-        auto result = WIRSQuery<WRec, false>::buffer_query(buffer, state, &parms);
-
-        total_samples += result.size();
-
-        for (size_t j=0; j<result.size(); j++) {
-            cnt[result[j].rec.key - 1]++;
-        }
-
-        WIRSQuery<WRec, false>::delete_buffer_query_state(state);
-    }
-
-    ck_assert(roughly_equal(cnt[0], (double) total_samples/4.0, total_samples, .05));
-    ck_assert(roughly_equal(cnt[1], (double) total_samples/4.0, total_samples, .05));
-    ck_assert(roughly_equal(cnt[2], (double) total_samples/2.0, total_samples, .05));
-
-    gsl_rng_free(parms.rng);
-    delete buffer;
-}
-END_TEST
-
-
-START_TEST(t_wirs_buffer_query_rejection)
-{
-    size_t n=1000;
-    auto buffer = create_weighted_mbuffer<WRec>(n);
-
-    uint64_t lower_key = 0;
-    uint64_t upper_key = 5;
-
-    size_t k = 1000;
-
-    size_t cnt[3] = {0};
-    wirs_query_parms<WRec> parms = {lower_key, upper_key, k};
-    parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
-
-    size_t total_samples = 0;
-
-    for (size_t i=0; i<1000; i++) {
-        auto state = WIRSQuery<WRec>::get_buffer_query_state(buffer, &parms);
-        ((WIRSBufferState<WRec> *) state)->sample_size = k;
-        auto result = WIRSQuery<WRec>::buffer_query(buffer, state, &parms);
-
-        total_samples += result.size();
-
-        for (size_t j=0; j<result.size(); j++) {
-            cnt[result[j].rec.key - 1]++;
-        }
-
-        WIRSQuery<WRec>::delete_buffer_query_state(state);
-    }
-
-    ck_assert(roughly_equal(cnt[0], (double) total_samples/4.0, total_samples, .05));
-    ck_assert(roughly_equal(cnt[1], (double) total_samples/4.0, total_samples, .05));
-    ck_assert(roughly_equal(cnt[2], (double) total_samples/2.0, total_samples, .05));
-
-    gsl_rng_free(parms.rng);
-    delete buffer;
-}
-END_TEST
-
-
-Suite *unit_testing()
-{
-    Suite *unit = suite_create("WIRS Shard Unit Testing");
-
-    TCase *create = tcase_create("de::WIRS constructor Testing");
-    tcase_add_test(create, t_mbuffer_init);
-    tcase_add_test(create, t_wirs_init);
-    tcase_set_timeout(create, 100);
-    suite_add_tcase(unit, create);
-
-
-    TCase *tombstone = tcase_create("de:WIRS::tombstone cancellation Testing");
-    tcase_add_test(tombstone, t_full_cancelation);
-    suite_add_tcase(unit, tombstone);
-
-
-    TCase *lookup = tcase_create("de:WIRS:point_lookup Testing");
-    tcase_add_test(lookup, t_point_lookup);
-    tcase_add_test(lookup, t_point_lookup_miss);
-    suite_add_tcase(unit, lookup);
-
-
-    TCase *sampling = tcase_create("de:WIRS::WIRSQuery Testing");
-    tcase_add_test(sampling, t_wirs_query);
-    tcase_add_test(sampling, t_wirs_query_merge);
-    tcase_add_test(sampling, t_wirs_buffer_query_rejection);
-    tcase_add_test(sampling, t_wirs_buffer_query_scan);
-    suite_add_tcase(unit, sampling);
-
-    return unit;
-}
-
-
-int shard_unit_tests()
-{
-    int failed = 0;
-    Suite *unit = unit_testing();
-    SRunner *unit_shardner = srunner_create(unit);
-
-    srunner_run_all(unit_shardner, CK_NORMAL);
-    failed = srunner_ntests_failed(unit_shardner);
-    srunner_free(unit_shardner);
-
-    return failed;
-}
-
-
-int main() 
-{
-    int unit_failed = shard_unit_tests();
-
-    return (unit_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
-}
-- 
cgit v1.2.3


From cc415c7c100a17c4e944915aeab01be99b14adb9 Mon Sep 17 00:00:00 2001
From: Douglas Rumbaugh <dbr4@psu.edu>
Date: Tue, 7 Nov 2023 13:36:11 -0500
Subject: Switched default DE test case over to ISAMTree

---
 tests/de_level_tag.cpp            |   5 +-
 tests/de_level_tomb.cpp           |   5 +-
 tests/de_tier_tag.cpp             |   5 +-
 tests/de_tier_tomb.cpp            |   5 +-
 tests/dynamic_extension_tests.inc | 206 ++++++++++++++++----------------------
 tests/internal_level_tests.cpp    |  13 +--
 6 files changed, 103 insertions(+), 136 deletions(-)

(limited to 'tests')

diff --git a/tests/de_level_tag.cpp b/tests/de_level_tag.cpp
index 822ccc2..f3f099d 100644
--- a/tests/de_level_tag.cpp
+++ b/tests/de_level_tag.cpp
@@ -15,11 +15,12 @@
 
 #include "testing.h"
 #include "framework/DynamicExtension.h"
-#include "shard/WIRS.h"
+#include "shard/ISAMTree.h"
+#include "query/rangequery.h"
 
 #include <check.h>
 using namespace de;
 
-typedef DynamicExtension<WRec, WIRS<WRec>, WIRSQuery<WRec>, LayoutPolicy::LEVELING, DeletePolicy::TAGGING, SerialScheduler> DE;
+typedef DynamicExtension<Rec, ISAMTree<Rec>, rq::Query<ISAMTree<Rec>, Rec>, LayoutPolicy::LEVELING, DeletePolicy::TAGGING, SerialScheduler> DE;
 
 #include "dynamic_extension_tests.inc"
diff --git a/tests/de_level_tomb.cpp b/tests/de_level_tomb.cpp
index 264b5b0..912743c 100644
--- a/tests/de_level_tomb.cpp
+++ b/tests/de_level_tomb.cpp
@@ -15,11 +15,12 @@
 
 #include "testing.h"
 #include "framework/DynamicExtension.h"
-#include "shard/WIRS.h"
+#include "shard/ISAMTree.h"
+#include "query/rangequery.h"
 
 #include <check.h>
 using namespace de;
 
-typedef DynamicExtension<WRec, WIRS<WRec>, WIRSQuery<WRec>, LayoutPolicy::LEVELING, DeletePolicy::TOMBSTONE, SerialScheduler> DE;
+typedef DynamicExtension<Rec, ISAMTree<Rec>, rq::Query<ISAMTree<Rec>, Rec>, LayoutPolicy::LEVELING, DeletePolicy::TOMBSTONE, SerialScheduler> DE;
 
 #include "dynamic_extension_tests.inc"
diff --git a/tests/de_tier_tag.cpp b/tests/de_tier_tag.cpp
index 2c263eb..712c203 100644
--- a/tests/de_tier_tag.cpp
+++ b/tests/de_tier_tag.cpp
@@ -16,11 +16,12 @@
 #include "testing.h"
 #include "framework/DynamicExtension.h"
 #include "framework/scheduling/SerialScheduler.h"
-#include "shard/WIRS.h"
+#include "shard/ISAMTree.h"
+#include "query/rangequery.h"
 
 #include <check.h>
 using namespace de;
 
-typedef DynamicExtension<WRec, WIRS<WRec>, WIRSQuery<WRec>, LayoutPolicy::TEIRING, DeletePolicy::TAGGING, SerialScheduler> DE;
+typedef DynamicExtension<Rec, ISAMTree<Rec>, rq::Query<ISAMTree<Rec>, Rec>, LayoutPolicy::TEIRING, DeletePolicy::TAGGING, SerialScheduler> DE;
 
 #include "dynamic_extension_tests.inc"
diff --git a/tests/de_tier_tomb.cpp b/tests/de_tier_tomb.cpp
index 509494a..f25ec34 100644
--- a/tests/de_tier_tomb.cpp
+++ b/tests/de_tier_tomb.cpp
@@ -15,11 +15,12 @@
 
 #include "testing.h"
 #include "framework/DynamicExtension.h"
-#include "shard/WIRS.h"
+#include "shard/ISAMTree.h"
+#include "query/rangequery.h"
 
 #include <check.h>
 using namespace de;
 
-typedef DynamicExtension<WRec, WIRS<WRec>, WIRSQuery<WRec>, LayoutPolicy::TEIRING, DeletePolicy::TOMBSTONE, SerialScheduler> DE;
+typedef DynamicExtension<Rec, ISAMTree<Rec>, rq::Query<ISAMTree<Rec>, Rec>, LayoutPolicy::TEIRING, DeletePolicy::TOMBSTONE, SerialScheduler> DE;
 
 #include "dynamic_extension_tests.inc"
diff --git a/tests/dynamic_extension_tests.inc b/tests/dynamic_extension_tests.inc
index 2f82e92..aa12e31 100644
--- a/tests/dynamic_extension_tests.inc
+++ b/tests/dynamic_extension_tests.inc
@@ -12,75 +12,74 @@
 
 START_TEST(t_create)
 {
-    auto ext_wirs = new DE(100, 2, 1);
+    auto test_de = new DE(100, 2, 1);
 
+    ck_assert_ptr_nonnull(test_de);
+    ck_assert_int_eq(test_de->get_record_count(), 0);
+    ck_assert_int_eq(test_de->get_height(), 0);
 
-    ck_assert_ptr_nonnull(ext_wirs);
-    ck_assert_int_eq(ext_wirs->get_record_count(), 0);
-    ck_assert_int_eq(ext_wirs->get_height(), 0);
-
-    delete ext_wirs;
+    delete test_de;
 }
 END_TEST
 
 
 START_TEST(t_insert)
 {
-    auto ext_wirs = new DE(100, 2, 1);
+    auto test_de = new DE(100, 2, 1);
 
     uint64_t key = 0;
     uint32_t val = 0;
     for (size_t i=0; i<100; i++) {
-        WRec r = {key, val, 1};
-        ck_assert_int_eq(ext_wirs->insert(r), 1);
+        Rec r = {key, val};
+        ck_assert_int_eq(test_de->insert(r), 1);
         key++;
         val++;
     }
 
-    ck_assert_int_eq(ext_wirs->get_height(), 0);
-    ck_assert_int_eq(ext_wirs->get_record_count(), 100);
+    ck_assert_int_eq(test_de->get_height(), 0);
+    ck_assert_int_eq(test_de->get_record_count(), 100);
 
-    delete ext_wirs;
+    delete test_de;
 }
 END_TEST
 
 
 START_TEST(t_debug_insert)
 {
-    auto ext_wirs = new DE(100, 2, 1);
+    auto test_de = new DE(100, 2, 1);
 
     uint64_t key = 0;
     uint32_t val = 0;
     for (size_t i=0; i<1000; i++) {
-        WRec r = {key, val, 1};
-        ck_assert_int_eq(ext_wirs->insert(r), 1);
-        ck_assert_int_eq(ext_wirs->get_record_count(), i+1);
+        Rec r = {key, val};
+        ck_assert_int_eq(test_de->insert(r), 1);
+        ck_assert_int_eq(test_de->get_record_count(), i+1);
         key++;
         val++;
     }
 
-    delete ext_wirs;
+    delete test_de;
 }
 END_TEST
 
 
 START_TEST(t_insert_with_mem_merges)
 {
-    auto ext_wirs = new DE(100, 2, 1);
+    auto test_de = new DE(100, 2, 1);
 
     uint64_t key = 0;
     uint32_t val = 0;
     for (size_t i=0; i<300; i++) {
-        WRec r = {key, val, 1};
-        ck_assert_int_eq(ext_wirs->insert(r), 1);
+        Rec r = {key, val};
+        ck_assert_int_eq(test_de->insert(r), 1);
         key++;
         val++;
     }
 
-    ck_assert_int_eq(ext_wirs->get_record_count(), 300);
-    ck_assert_int_eq(ext_wirs->get_height(), 1);
+    ck_assert_int_eq(test_de->get_record_count(), 300);
+    ck_assert_int_eq(test_de->get_height(), 1);
 
-    delete ext_wirs;
+    delete test_de;
 }
 END_TEST
 
@@ -88,13 +87,13 @@ END_TEST
 /*
 START_TEST(t_range_sample_memtable)
 {
-    auto ext_wirs = new DE(100, 2, 1);
+    auto test_de = new DE(100, 2, 1);
 
     uint64_t key = 0;
     uint32_t val = 0;
     for (size_t i=0; i<100; i++) {
-        WRec r = {key, val, 1};
-        ck_assert_int_eq(ext_wirs->insert(r), 1);
+        Rec r = {key, val};
+        ck_assert_int_eq(test_de->insert(r), 1);
         key++;
         val++;
     }
@@ -104,9 +103,9 @@ START_TEST(t_range_sample_memtable)
 
     char *buf = (char *) std::aligned_alloc(SECTOR_SIZE, PAGE_SIZE);
     char *util_buf = (char *) std::aligned_alloc(SECTOR_SIZE, PAGE_SIZE);
-    WRec sample_set[100];
+    Rec sample_set[100];
 
-    ext_wirs->range_sample(sample_set, lower_bound, upper_bound, 100);
+    test_de->range_sample(sample_set, lower_bound, upper_bound, 100);
 
     for(size_t i=0; i<100; i++) {
         ck_assert_int_le(sample_set[i].key, upper_bound);
@@ -116,20 +115,20 @@ START_TEST(t_range_sample_memtable)
     free(buf);
     free(util_buf);
 
-    delete ext_wirs;
+    delete test_de;
 }
 END_TEST
 
 
 START_TEST(t_range_sample_memlevels)
 {
-    auto ext_wirs = new DE(100, 2, 1);
+    auto test_de = new DE(100, 2, 1);
 
     uint64_t key = 0;
     uint32_t val = 0;
     for (size_t i=0; i<300; i++) {
-        WRec r = {key, val, 1};
-        ck_assert_int_eq(ext_wirs->insert(r), 1);
+        Rec r = {key, val};
+        ck_assert_int_eq(test_de->insert(r), 1);
         key++;
         val++;
     }
@@ -140,8 +139,8 @@ START_TEST(t_range_sample_memlevels)
     char *buf = (char *) std::aligned_alloc(SECTOR_SIZE, PAGE_SIZE);
     char *util_buf = (char *) std::aligned_alloc(SECTOR_SIZE, PAGE_SIZE);
 
-    WRec sample_set[100];
-    ext_wirs->range_sample(sample_set, lower_bound, upper_bound, 100);
+    Rec sample_set[100];
+    test_de->range_sample(sample_set, lower_bound, upper_bound, 100);
 
     for(size_t i=0; i<100; i++) {
         ck_assert_int_le(sample_set[i].key, upper_bound);
@@ -151,33 +150,19 @@ START_TEST(t_range_sample_memlevels)
     free(buf);
     free(util_buf);
 
-    delete ext_wirs;
+    delete test_de;
 }
 END_TEST
 */
 
-START_TEST(t_range_sample_weighted)
+START_TEST(t_range_query)
 {
-    auto ext_wirs = new DE(100, 2, 1);
+    auto test_de = new DE(100, 2, 1);
     size_t n = 10000;
 
     std::vector<uint64_t> keys;
-
-    uint64_t key = 1;
-    for (size_t i=0; i< n / 2; i++) {
-        keys.push_back(key);
-    }
-
-    // put in a quarter of the count with weight two.
-    key = 2;
-    for (size_t i=0; i< n / 4; i++) {
-        keys.push_back(key);
-    }
-
-    // the remaining quarter with weight four.
-    key = 3;
-    for (size_t i=0; i< n / 4; i++) {
-        keys.push_back(key);
+    for (size_t i=0; i<n; i++) {
+        keys.push_back(rand() % 25000);
     }
 
     std::random_device rd;
@@ -185,48 +170,31 @@ START_TEST(t_range_sample_weighted)
     std::shuffle(keys.begin(), keys.end(), gen);
 
     for (size_t i=0; i<keys.size(); i++) {
-        uint64_t weight;
-        if (keys[i] == 1)  {
-            weight = 2;
-        } else if (keys[i] == 2) {
-            weight = 4;
-        } else {
-            weight = 8;
-        }
-
-        WRec r = {keys[i], (uint32_t) i, weight};
-        ext_wirs->insert(r);
+        Rec r = {keys[i], (uint32_t) i};
+        ck_assert_int_eq(test_de->insert(r), 1);
     }
-    size_t k = 1000;
-    uint64_t lower_key = 0;
-    uint64_t upper_key = 5;
 
-    size_t cnt[3] = {0};
-    size_t total_samples = 0;
+    std::sort(keys.begin(), keys.end());
+
+    auto idx = rand() % (keys.size() - 250);
 
-    wirs_query_parms<WRec> p;
+    uint64_t lower_key = keys[idx];
+    uint64_t upper_key = keys[idx + 250];
+
+    rq::Parms<Rec> p;
     p.lower_bound = lower_key;
     p.upper_bound = upper_key;
-    p.sample_size = k;
-    p.rng = gsl_rng_alloc(gsl_rng_mt19937);
-
-    for (size_t i=0; i<1000; i++) {
 
-        auto result = ext_wirs->query(&p);
-        auto r = result.get();
-        total_samples += r.size();
+    auto result = test_de->query(&p);
+    auto r = result.get();
+    std::sort(r.begin(), r.end());
+    ck_assert_int_eq(r.size(), 251);
 
-        for (size_t j=0; j<r.size(); j++) {
-            cnt[r[j].key - 1]++;
-        }
+    for (size_t i=0; i<r.size(); i++) {
+        ck_assert_int_eq(r[i].key, keys[idx + i]);
     }
 
-    ck_assert(roughly_equal(cnt[0], (double) total_samples/4.0, total_samples, .03));
-    ck_assert(roughly_equal(cnt[1], (double) total_samples/4.0, total_samples, .03));
-    ck_assert(roughly_equal(cnt[2], (double) total_samples/2.0, total_samples, .03));
-
-    gsl_rng_free(p.rng);
-    delete ext_wirs;
+    delete test_de;
 }
 END_TEST
 
@@ -234,7 +202,7 @@ END_TEST
 START_TEST(t_tombstone_merging_01)
 {
     size_t reccnt = 100000;
-    auto ext_wirs = new DE(100, 2, .01);
+    auto test_de = new DE(100, 2, .01);
 
     auto rng = gsl_rng_alloc(gsl_rng_mt19937);
 
@@ -254,16 +222,16 @@ START_TEST(t_tombstone_merging_01)
     size_t deletes = 0;
     size_t cnt=0;
     for (auto rec : records) {
-        WRec r = {rec.first, rec.second, 1};
-        ck_assert_int_eq(ext_wirs->insert(r), 1);
+        Rec r = {rec.first, rec.second};
+        ck_assert_int_eq(test_de->insert(r), 1);
 
          if (gsl_rng_uniform(rng) < 0.05 && !to_delete.empty()) {
             std::vector<std::pair<uint64_t, uint32_t>> 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++) {
-                WRec dr = {del_vec[i].first, del_vec[i].second, 1};
-                ext_wirs->erase(dr);
+                Rec dr = {del_vec[i].first, del_vec[i].second};
+                test_de->erase(dr);
                 deletes++;
                 to_delete.erase(del_vec[i]);
                 deleted.insert(del_vec[i]);
@@ -274,24 +242,24 @@ START_TEST(t_tombstone_merging_01)
             to_delete.insert(rec);
         }
 
-        ck_assert(ext_wirs->validate_tombstone_proportion());
+        ck_assert(test_de->validate_tombstone_proportion());
     }
 
-    ck_assert(ext_wirs->validate_tombstone_proportion());
+    ck_assert(test_de->validate_tombstone_proportion());
 
     gsl_rng_free(rng);
-    delete ext_wirs;
+    delete test_de;
 }
 END_TEST
 
 DE *create_test_tree(size_t reccnt, size_t memlevel_cnt) {
     auto rng = gsl_rng_alloc(gsl_rng_mt19937);
 
-    auto ext_wirs = new DE(1000, 2, 1);
+    auto test_de = new DE(1000, 2, 1);
 
-    std::set<WRec> records; 
-    std::set<WRec> to_delete;
-    std::set<WRec> deleted;
+    std::set<Rec> records; 
+    std::set<Rec> to_delete;
+    std::set<Rec> deleted;
 
     while (records.size() < reccnt) {
         uint64_t key = rand();
@@ -304,14 +272,14 @@ DE *create_test_tree(size_t reccnt, size_t memlevel_cnt) {
 
     size_t deletes = 0;
     for (auto rec : records) {
-        ck_assert_int_eq(ext_wirs->insert(rec), 1);
+        ck_assert_int_eq(test_de->insert(rec), 1);
 
          if (gsl_rng_uniform(rng) < 0.05 && !to_delete.empty()) {
-            std::vector<WRec> del_vec;
+            std::vector<Rec> 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++) {
-                ext_wirs->erase(del_vec[i]);
+                test_de->erase(del_vec[i]);
                 deletes++;
                 to_delete.erase(del_vec[i]);
                 deleted.insert(del_vec[i]);
@@ -325,7 +293,7 @@ DE *create_test_tree(size_t reccnt, size_t memlevel_cnt) {
 
     gsl_rng_free(rng);
 
-    return ext_wirs;
+    return test_de;
 }
 
 START_TEST(t_static_structure)
@@ -333,11 +301,11 @@ START_TEST(t_static_structure)
     auto rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     size_t reccnt = 100000;
-    auto ext_wirs = new DE(100, 2, 1);
+    auto test_de = new DE(100, 2, 1);
 
-    std::set<WRec> records; 
-    std::set<WRec> to_delete;
-    std::set<WRec> deleted;
+    std::set<Rec> records; 
+    std::set<Rec> to_delete;
+    std::set<Rec> deleted;
 
     while (records.size() < reccnt) {
         uint64_t key = rand();
@@ -345,7 +313,7 @@ START_TEST(t_static_structure)
 
         if (records.find({key, val}) != records.end()) continue;
 
-        records.insert({key, val, 1});
+        records.insert({key, val});
     }
 
     size_t deletes = 0;
@@ -353,15 +321,15 @@ START_TEST(t_static_structure)
     size_t k=0;
     for (auto rec : records) {
         k++;
-        ck_assert_int_eq(ext_wirs->insert(rec), 1);
+        ck_assert_int_eq(test_de->insert(rec), 1);
         t_reccnt++;
 
          if (gsl_rng_uniform(rng) < 0.05 && !to_delete.empty()) {
-            std::vector<WRec> del_vec;
+            std::vector<Rec> 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++) {
-                ck_assert_int_eq(ext_wirs->erase(del_vec[i]), 1);
+                ck_assert_int_eq(test_de->erase(del_vec[i]), 1);
 
                 deletes++;
                 to_delete.erase(del_vec[i]);
@@ -374,7 +342,7 @@ START_TEST(t_static_structure)
         }
     }
 
-    auto flat = ext_wirs->create_static_structure();
+    auto flat = test_de->create_static_structure();
     ck_assert_int_eq(flat->get_record_count(), reccnt - deletes);
 
     uint64_t prev_key = 0;
@@ -386,7 +354,7 @@ START_TEST(t_static_structure)
 
     gsl_rng_free(rng);
     delete flat;
-    delete ext_wirs;
+    delete test_de;
 }
 END_TEST
 
@@ -399,21 +367,15 @@ Suite *unit_testing()
     tcase_add_test(create, t_create);
     suite_add_tcase(unit, create);
 
-    TCase *insert = tcase_create("de::DynamicExtension<WIRS>::insert Testing");
+    TCase *insert = tcase_create("de::DynamicExtension<ISAMTree>::insert Testing");
     tcase_add_test(insert, t_insert);
     tcase_add_test(insert, t_insert_with_mem_merges);
     tcase_add_test(insert, t_debug_insert);
     suite_add_tcase(unit, insert);
 
-    TCase *sampling = tcase_create("de::DynamicExtension<WIRS>::range_sample Testing");
-
-    tcase_add_test(sampling, t_range_sample_weighted);
-    suite_add_tcase(unit, sampling);
-
-    /*
-    tcase_add_test(sampling, t_range_sample_memtable);
-    tcase_add_test(sampling, t_range_sample_memlevels);
-    */
+    TCase *query = tcase_create("de::DynamicExtension<ISAMTree>::range_query Testing");
+    tcase_add_test(query, t_range_query);
+    suite_add_tcase(unit, query);
 
     TCase *ts = tcase_create("de::DynamicExtension::tombstone_compaction Testing");
     tcase_add_test(ts, t_tombstone_merging_01);
diff --git a/tests/internal_level_tests.cpp b/tests/internal_level_tests.cpp
index 056e458..1009ea8 100644
--- a/tests/internal_level_tests.cpp
+++ b/tests/internal_level_tests.cpp
@@ -9,7 +9,8 @@
  * All rights reserved. Published under the Modified BSD License.
  *
  */
-#include "shard/WIRS.h"
+#include "shard/ISAMTree.h"
+#include "query/rangequery.h"
 #include "framework/structure/InternalLevel.h"
 #include "framework/interface/Record.h"
 #include "framework/interface/Query.h"
@@ -21,12 +22,12 @@
 
 using namespace de;
 
-typedef InternalLevel<WRec, WIRS<WRec>, WIRSQuery<WRec>> ILevel;
+typedef InternalLevel<Rec, ISAMTree<Rec>, rq::Query<ISAMTree<Rec>, Rec>> ILevel;
 
 START_TEST(t_memlevel_merge)
 {
-    auto tbl1 = create_test_mbuffer<WRec>(100);
-    auto tbl2 = create_test_mbuffer<WRec>(100);
+    auto tbl1 = create_test_mbuffer<Rec>(100);
+    auto tbl2 = create_test_mbuffer<Rec>(100);
 
     auto base_level = new ILevel(1, 1);
     base_level->append_buffer(tbl1);
@@ -48,8 +49,8 @@ START_TEST(t_memlevel_merge)
 
 
 ILevel *create_test_memlevel(size_t reccnt) {
-    auto tbl1 = create_test_mbuffer<WRec>(reccnt/2);
-    auto tbl2 = create_test_mbuffer<WRec>(reccnt/2);
+    auto tbl1 = create_test_mbuffer<Rec>(reccnt/2);
+    auto tbl2 = create_test_mbuffer<Rec>(reccnt/2);
 
     auto base_level = new ILevel(1, 2);
     base_level->append_buffer(tbl1); 
-- 
cgit v1.2.3