From 9fe190f5d500e22b0894095e7c917f9c652e0a64 Mon Sep 17 00:00:00 2001
From: Douglas Rumbaugh <dbr4@psu.edu>
Date: Wed, 20 Mar 2024 17:30:14 -0400
Subject: Updates/progress towards succinct trie support

---
 tests/include/shard_standard.h |   6 +-
 tests/include/shard_string.h   | 168 +++++++++++++++++++++++++++++++++++++++++
 tests/include/testing.h        |  59 +++++++++++++--
 3 files changed, 223 insertions(+), 10 deletions(-)
 create mode 100644 tests/include/shard_string.h

(limited to 'tests/include')

diff --git a/tests/include/shard_standard.h b/tests/include/shard_standard.h
index 7d17dcb..55e4c7b 100644
--- a/tests/include/shard_standard.h
+++ b/tests/include/shard_standard.h
@@ -37,17 +37,17 @@ START_TEST(t_mbuffer_init)
     auto buffer = new MutableBuffer<R>(512, 1024);
     for (uint64_t i = 512; i > 0; i--) {
         uint32_t v = i;
-        buffer->append({i, v, 1});
+        buffer->append({i, v});
     }
     
     for (uint64_t i = 1; i <= 256; ++i) {
         uint32_t v = i;
-        buffer->append({i, v, 1}, true);
+        buffer->append({i, v}, true);
     }
 
     for (uint64_t i = 257; i <= 512; ++i) {
         uint32_t v = i + 1;
-        buffer->append({i, v, 1});
+        buffer->append({i, v});
     }
 
     Shard* shard = new Shard(buffer->get_buffer_view());
diff --git a/tests/include/shard_string.h b/tests/include/shard_string.h
new file mode 100644
index 0000000..27ee782
--- /dev/null
+++ b/tests/include/shard_string.h
@@ -0,0 +1,168 @@
+/*
+ * tests/include/shard_string.h
+ *
+ * Standardized unit tests for Shard objects with string keys
+ *
+ * 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. For other types of record, 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/FSTrie.h"
+#include "testing.h"
+#include <check.h>
+using namespace de;
+typedef StringRec R;
+typedef FSTrie<R> Shard;
+
+START_TEST(t_mbuffer_init)
+{
+
+    auto recs = read_string_data(kjv_wordlist, 1024);
+
+    auto buffer = new MutableBuffer<R>(512, 1024);
+
+    for (uint64_t i = 0; i < 512; i++) {
+        buffer->append(recs[i]);
+    }
+    
+    for (uint64_t i = 0; i < 256; ++i) {
+        buffer->delete_record(recs[i]);
+    }
+
+    for (uint64_t i = 512; i < 768; ++i) {
+        buffer->append(recs[i]);
+    }
+
+    Shard* shard = new Shard(buffer->get_buffer_view());
+    ck_assert_uint_eq(shard->get_record_count(), 512);
+
+    delete buffer;
+    delete shard;
+}
+
+
+START_TEST(t_shard_init)
+{
+    size_t n = 512;
+    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());
+    auto shard3 = new Shard(mbuffer3->get_buffer_view());
+
+    std::vector<Shard*> shards = {shard1, shard2, shard3};
+    auto shard4 = new Shard(shards);
+
+    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_test_mbuffer<R>(n);
+    auto shard = Shard(buffer->get_buffer_view());
+
+    {
+        auto view = buffer->get_buffer_view();
+
+        for (size_t i=0; i<n; i++) {
+            R r;
+            auto rec = view.get(i);
+            r.key = rec->rec.key;
+            r.value = rec->rec.value;
+
+            auto result = shard.point_lookup(r);
+            ck_assert_ptr_nonnull(result);
+            ck_assert_str_eq(result->rec.key.c_str(), r.key.c_str());
+            ck_assert_int_eq(result->rec.value, r.value);
+            fprintf(stderr, "%ld\n", i);
+        }
+    }
+
+    delete buffer;
+}
+END_TEST
+
+
+START_TEST(t_point_lookup_miss) 
+{
+    size_t n = 10000;
+
+    auto buffer = create_test_mbuffer<R>(n);
+    auto shard = Shard(buffer->get_buffer_view());
+
+    for (size_t i=n + 100; i<2*n; i++) {
+        R r;
+        r.key = std::string("computer");
+        r.value = 1234;
+
+        auto result = shard.point_lookup(r);
+        ck_assert_ptr_null(result);
+    }
+
+    delete buffer;
+}
+
+static void inject_shard_tests(Suite *suite) {
+    TCase *create = tcase_create("Shard constructor Testing");
+    tcase_add_test(create, t_mbuffer_init);
+    tcase_add_test(create, t_shard_init);
+    tcase_set_timeout(create, 100);
+    suite_add_tcase(suite, create);
+
+    TCase *pointlookup = tcase_create("Shard point lookup Testing"); 
+    tcase_add_test(pointlookup, t_point_lookup);
+    tcase_add_test(pointlookup, t_point_lookup_miss); 
+    suite_add_tcase(suite, pointlookup);
+}
diff --git a/tests/include/testing.h b/tests/include/testing.h
index f935b53..a3c54c0 100644
--- a/tests/include/testing.h
+++ b/tests/include/testing.h
@@ -15,6 +15,8 @@
 
 #include <unistd.h>
 #include <fcntl.h>
+#include <fstream>
+#include <sstream>
 
 #include "util/types.h"
 #include "psu-util/alignment.h"
@@ -25,6 +27,38 @@ typedef de::WeightedRecord<uint64_t, uint32_t, uint64_t> WRec;
 typedef de::Record<uint64_t, uint32_t> Rec;
 typedef de::EuclidPoint<uint64_t> PRec;
 
+typedef de::Record<std::string, uint64_t> StringRec;
+
+std::string kjv_wordlist = "tests/data/kjv-wordlist.txt";
+std::string summa_wordlist = "tests/data/summa-wordlist.txt";
+
+static std::vector<StringRec> read_string_data(std::string fname, size_t n) {
+    std::vector<StringRec> vec;
+    vec.reserve(n);
+
+    std::fstream file;
+    file.open(fname, std::ios::in);
+
+    for (size_t i=0; i<n; i++) {
+        std::string line;
+        if (!std::getline(file, line, '\n')) break;
+
+        std::stringstream ls(line);
+        StringRec r;
+        std::string field;
+
+        std::getline(ls, field, '\t');
+        r.value = atol(field.c_str());
+        std::getline(ls, field, '\n');
+        r.key = std::string(field);
+
+        vec.push_back(r);
+    }
+
+    return vec;
+}
+
+
 template <de::RecordInterface R> 
 std::vector<R> strip_wrapping(std::vector<de::Wrapped<R>> vec) {
     std::vector<R> out(vec.size());
@@ -83,15 +117,26 @@ static de::MutableBuffer<R> *create_test_mbuffer(size_t cnt)
 
     R rec;
     if constexpr (de::KVPInterface<R>) {
-        for (size_t i = 0; i < cnt; i++) {
-            rec.key = rand();
-            rec.value = rand();
-
-            if constexpr (de::WeightedRecordInterface<R>) {
-                rec.weight = 1;
+        if constexpr (std::is_same_v<R, StringRec>) {
+            auto records = read_string_data(kjv_wordlist, cnt);
+            for (size_t i=0; i<cnt; i++) {
+                if constexpr (de::WeightedRecordInterface<R>) {
+                    rec.weight = 1;
+                }
+
+                buffer->append(records[i]);
             }
+        } else {
+            for (size_t i = 0; i < cnt; i++) {
+                rec.key = rand();
+                rec.value = rand();
+
+                if constexpr (de::WeightedRecordInterface<R>) {
+                    rec.weight = 1;
+                }
 
-            buffer->append(rec);
+                buffer->append(rec);
+            }
         }
     } else if constexpr (de::NDRecordInterface<R>) {
         for (size_t i=0; i<cnt; i++) {
-- 
cgit v1.2.3


From 147f0df58e1ff4973bffb7e4628e6b2fdc20eb57 Mon Sep 17 00:00:00 2001
From: Douglas Rumbaugh <dbr4@psu.edu>
Date: Fri, 22 Mar 2024 14:04:40 -0400
Subject: FSTrie testing and debugging

---
 tests/include/shard_string.h | 8 +++-----
 tests/include/testing.h      | 6 +++---
 2 files changed, 6 insertions(+), 8 deletions(-)

(limited to 'tests/include')

diff --git a/tests/include/shard_string.h b/tests/include/shard_string.h
index 27ee782..fa51630 100644
--- a/tests/include/shard_string.h
+++ b/tests/include/shard_string.h
@@ -58,7 +58,7 @@ START_TEST(t_mbuffer_init)
 
 START_TEST(t_shard_init)
 {
-    size_t n = 512;
+    size_t n = 2048;
     auto mbuffer1 = create_test_mbuffer<R>(n);
     auto mbuffer2 = create_test_mbuffer<R>(n);
     auto mbuffer3 = create_test_mbuffer<R>(n);
@@ -117,16 +117,14 @@ START_TEST(t_point_lookup)
         auto view = buffer->get_buffer_view();
 
         for (size_t i=0; i<n; i++) {
-            R r;
             auto rec = view.get(i);
-            r.key = rec->rec.key;
-            r.value = rec->rec.value;
+            R r = rec->rec;
 
             auto result = shard.point_lookup(r);
             ck_assert_ptr_nonnull(result);
             ck_assert_str_eq(result->rec.key.c_str(), r.key.c_str());
             ck_assert_int_eq(result->rec.value, r.value);
-            fprintf(stderr, "%ld\n", i);
+            //fprintf(stderr, "%ld\n", i);
         }
     }
 
diff --git a/tests/include/testing.h b/tests/include/testing.h
index a3c54c0..2315daa 100644
--- a/tests/include/testing.h
+++ b/tests/include/testing.h
@@ -51,7 +51,7 @@ static std::vector<StringRec> read_string_data(std::string fname, size_t n) {
         r.value = atol(field.c_str());
         std::getline(ls, field, '\n');
         r.key = std::string(field);
-
+        
         vec.push_back(r);
     }
 
@@ -116,8 +116,8 @@ static de::MutableBuffer<R> *create_test_mbuffer(size_t cnt)
     auto buffer = new de::MutableBuffer<R>(cnt/2, cnt);
 
     R rec;
-    if constexpr (de::KVPInterface<R>) {
-        if constexpr (std::is_same_v<R, StringRec>) {
+    if constexpr (de::KVPInterface<R>){
+        if constexpr (std::is_same_v<decltype(R::key), std::string>) {
             auto records = read_string_data(kjv_wordlist, cnt);
             for (size_t i=0; i<cnt; i++) {
                 if constexpr (de::WeightedRecordInterface<R>) {
-- 
cgit v1.2.3


From 7619c90e10adc441e525c98ad068a3639096d0c9 Mon Sep 17 00:00:00 2001
From: Douglas Rumbaugh <dbr4@psu.edu>
Date: Fri, 22 Mar 2024 14:22:44 -0400
Subject: Concurrent Extension test cleanup/minor tweaks

---
 tests/include/concurrent_extension.h | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

(limited to 'tests/include')

diff --git a/tests/include/concurrent_extension.h b/tests/include/concurrent_extension.h
index 0993fac..2948292 100644
--- a/tests/include/concurrent_extension.h
+++ b/tests/include/concurrent_extension.h
@@ -170,10 +170,8 @@ START_TEST(t_range_query)
     p.lower_bound = lower_key;
     p.upper_bound = upper_key;
 
-    //fprintf(stderr, "query start\n");
     auto result = test_de->query(&p);
     auto r = result.get();
-    //fprintf(stderr, "query stop\n");
     std::sort(r.begin(), r.end());
 
     ck_assert_int_eq(r.size(), 251);
@@ -349,12 +347,7 @@ START_TEST(t_static_structure)
     uint64_t prev_key = 0;
     for (size_t i=0; i<flat->get_record_count(); i++) {
         auto k = flat->get_record_at(i)->rec.key;
-        if (flat->get_record_at(i)->is_tombstone()) {
-            fprintf(stderr, "%ld %ld %ld\n", flat->get_record_at(i-1)->rec.key,
-                    flat->get_record_at(i)->rec.key, 
-                    flat->get_record_at(i+1)->rec.key);
-        }
-     //   ck_assert(!flat->get_record_at(i)->is_tombstone());
+        //ck_assert(!flat->get_record_at(i)->is_tombstone());
         ck_assert_int_ge(k, prev_key);
         prev_key = k;
     }
-- 
cgit v1.2.3


From fb4312a883dd0e382ecbcfe1119479e6f44d32a6 Mon Sep 17 00:00:00 2001
From: Douglas Rumbaugh <dbr4@psu.edu>
Date: Fri, 22 Mar 2024 15:35:14 -0400
Subject: PointLookup: added a point lookup query for unique indexes, and some
 tests

---
 tests/include/pointlookup.h | 111 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 111 insertions(+)
 create mode 100644 tests/include/pointlookup.h

(limited to 'tests/include')

diff --git a/tests/include/pointlookup.h b/tests/include/pointlookup.h
new file mode 100644
index 0000000..bf4810b
--- /dev/null
+++ b/tests/include/pointlookup.h
@@ -0,0 +1,111 @@
+/*
+ * tests/include/pointlookup.h
+ *
+ * Standardized unit tests for point lookups against supporting
+ * shard types (must be unique for the moment)
+ *
+ * Copyright (C) 2024 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/FSTrie.h"
+#include "query/pointlookup.h"
+#include "testing.h"
+
+#include <check.h>
+
+using namespace de;
+typedef StringRec R;
+typedef FSTrie<R> Shard;
+
+START_TEST(t_point_lookup_query)
+{
+    auto buffer = create_test_mbuffer<R>(1000);
+    auto shard = Shard(buffer->get_buffer_view());
+
+    pl::Parms<R> parms;
+    {
+        auto bv = buffer->get_buffer_view();
+        for (size_t i=0; i<bv.get_record_count(); i++) {
+            auto key = bv.get(i)->rec.key;
+
+            parms.search_key = key;
+            auto state = pl::Query<R, Shard>::get_query_state(&shard, &parms);
+            auto result = pl::Query<R, Shard>::query(&shard, state, &parms);
+            pl::Query<R, Shard>::delete_query_state(state);
+
+            ck_assert_int_eq(result.size(), 1);
+            ck_assert_str_eq(result[0].rec.key.c_str(), key.c_str());
+            ck_assert_int_eq(result[0].rec.value, bv.get(i)->rec.value);
+        }
+
+        /* point lookup miss; result size should be 0 */
+        parms.search_key = "computer";
+        auto state = pl::Query<R, Shard>::get_query_state(&shard, &parms);
+        auto result = pl::Query<R, Shard>::query(&shard, state, &parms);
+        pl::Query<R, Shard>::delete_query_state(state);
+
+        ck_assert_int_eq(result.size(), 0);
+    }
+
+    delete buffer;
+}
+END_TEST
+
+
+START_TEST(t_buffer_point_lookup)
+{
+
+    auto buffer = create_test_mbuffer<R>(1000);
+    pl::Parms<R> parms;
+    {
+        auto view = buffer->get_buffer_view();
+        for (int i=view.get_record_count()-1; i>=0; i--) {
+            parms.search_key = view.get(i)->rec.key;
+
+            auto state = pl::Query<R, Shard>::get_buffer_query_state(&view, &parms);
+            auto result = pl::Query<R, Shard>::buffer_query(state, &parms);
+            pl::Query<R, Shard>::delete_buffer_query_state(state);
+
+            ck_assert_int_eq(result.size(), 1);
+            ck_assert_str_eq(result[0].rec.key.c_str(), view.get(i)->rec.key.c_str());
+            ck_assert_int_eq(result[0].rec.value, view.get(i)->rec.value);
+        }
+
+        /* point lookup miss; result size should be 0 */
+        parms.search_key = "computer";
+        auto state = pl::Query<R, Shard>::get_buffer_query_state(&view, &parms);
+        auto result = pl::Query<R, Shard>::buffer_query(state, &parms);
+        pl::Query<R, Shard>::delete_buffer_query_state(state);
+
+        ck_assert_int_eq(result.size(), 0);
+    }
+
+    delete buffer;
+}
+END_TEST
+
+
+static void inject_pointlookup_tests(Suite *suite) {
+    TCase *point_lookup_query = tcase_create("Point Lookup Testing"); 
+    tcase_add_test(point_lookup_query, t_point_lookup_query); 
+    tcase_add_test(point_lookup_query, t_buffer_point_lookup); 
+    suite_add_tcase(suite, point_lookup_query);
+}
-- 
cgit v1.2.3


From b25beb13773072c3b143842b45a7c32a1108f347 Mon Sep 17 00:00:00 2001
From: Douglas Rumbaugh <dbr4@psu.edu>
Date: Mon, 15 Apr 2024 14:00:27 -0400
Subject: Updated FSTrie to use const char * instead of std::string

Note: this requires the caller to manage the memory of the strings
---
 tests/include/concurrent_extension.h |  6 +--
 tests/include/pointlookup.h          | 18 ++++----
 tests/include/rangecount.h           | 18 +++-----
 tests/include/rangequery.h           | 18 +++-----
 tests/include/shard_standard.h       | 10 ++---
 tests/include/shard_string.h         |  7 ++-
 tests/include/testing.h              | 82 +++++++++++++++---------------------
 7 files changed, 61 insertions(+), 98 deletions(-)

(limited to 'tests/include')

diff --git a/tests/include/concurrent_extension.h b/tests/include/concurrent_extension.h
index 2948292..927a094 100644
--- a/tests/include/concurrent_extension.h
+++ b/tests/include/concurrent_extension.h
@@ -97,8 +97,7 @@ START_TEST(t_insert_with_mem_merges)
     R r = {key, val};
     for (size_t i=0; i<1000; i++) {
         ck_assert_int_eq(test_de->insert(r), 1);
-        r.key++;
-        r.value++;
+        r = R{r.key + 1, r.value + 1};
     }
 
     ck_assert_int_eq(test_de->get_record_count(), 1000);
@@ -114,8 +113,7 @@ START_TEST(t_insert_with_mem_merges)
     size_t cnt = 0;
     do {
         if (test_de->insert(r)) {
-            r.key++;
-            r.value++;
+            r = R{r.key + 1, r.value + 1};
             cnt++;
             ck_assert_int_eq(test_de->get_record_count(), cnt + 1000);
         } else {
diff --git a/tests/include/pointlookup.h b/tests/include/pointlookup.h
index bf4810b..84e71f2 100644
--- a/tests/include/pointlookup.h
+++ b/tests/include/pointlookup.h
@@ -40,24 +40,25 @@ START_TEST(t_point_lookup_query)
     auto buffer = create_test_mbuffer<R>(1000);
     auto shard = Shard(buffer->get_buffer_view());
 
-    pl::Parms<R> parms;
     {
         auto bv = buffer->get_buffer_view();
         for (size_t i=0; i<bv.get_record_count(); i++) {
             auto key = bv.get(i)->rec.key;
 
-            parms.search_key = key;
+            pl::Parms<R> parms = {key};
             auto state = pl::Query<R, Shard>::get_query_state(&shard, &parms);
             auto result = pl::Query<R, Shard>::query(&shard, state, &parms);
             pl::Query<R, Shard>::delete_query_state(state);
 
             ck_assert_int_eq(result.size(), 1);
-            ck_assert_str_eq(result[0].rec.key.c_str(), key.c_str());
+            ck_assert_str_eq(result[0].rec.key, key);
             ck_assert_int_eq(result[0].rec.value, bv.get(i)->rec.value);
         }
 
         /* point lookup miss; result size should be 0 */
-        parms.search_key = "computer";
+        const char *c = "computer";
+        pl::Parms<R> parms = {c};
+
         auto state = pl::Query<R, Shard>::get_query_state(&shard, &parms);
         auto result = pl::Query<R, Shard>::query(&shard, state, &parms);
         pl::Query<R, Shard>::delete_query_state(state);
@@ -74,23 +75,24 @@ START_TEST(t_buffer_point_lookup)
 {
 
     auto buffer = create_test_mbuffer<R>(1000);
-    pl::Parms<R> parms;
     {
         auto view = buffer->get_buffer_view();
         for (int i=view.get_record_count()-1; i>=0; i--) {
-            parms.search_key = view.get(i)->rec.key;
+            pl::Parms<R> parms = {view.get(i)->rec.key};
 
             auto state = pl::Query<R, Shard>::get_buffer_query_state(&view, &parms);
             auto result = pl::Query<R, Shard>::buffer_query(state, &parms);
             pl::Query<R, Shard>::delete_buffer_query_state(state);
 
             ck_assert_int_eq(result.size(), 1);
-            ck_assert_str_eq(result[0].rec.key.c_str(), view.get(i)->rec.key.c_str());
+            ck_assert_str_eq(result[0].rec.key, view.get(i)->rec.key);
             ck_assert_int_eq(result[0].rec.value, view.get(i)->rec.value);
         }
 
         /* point lookup miss; result size should be 0 */
-        parms.search_key = "computer";
+        const char *c = "computer";
+        pl::Parms<R> parms = {c};
+
         auto state = pl::Query<R, Shard>::get_buffer_query_state(&view, &parms);
         auto result = pl::Query<R, Shard>::buffer_query(state, &parms);
         pl::Query<R, Shard>::delete_buffer_query_state(state);
diff --git a/tests/include/rangecount.h b/tests/include/rangecount.h
index fdd66d9..c97d64c 100644
--- a/tests/include/rangecount.h
+++ b/tests/include/rangecount.h
@@ -40,9 +40,7 @@ START_TEST(t_range_count)
     auto buffer = create_sequential_mbuffer<R>(100, 1000);
     auto shard = Shard(buffer->get_buffer_view());
 
-    rc::Parms<R> parms;
-    parms.lower_bound = 300;
-    parms.upper_bound = 500;
+    rc::Parms<R> parms = {300, 500};
 
     auto state = rc::Query<R, Shard>::get_query_state(&shard, &parms);
     auto result = rc::Query<R, Shard>::query(&shard, state, &parms);
@@ -60,9 +58,7 @@ START_TEST(t_buffer_range_count)
 {
     auto buffer = create_sequential_mbuffer<R>(100, 1000);
 
-    rc::Parms<R> parms;
-    parms.lower_bound = 300;
-    parms.upper_bound = 500;
+    rc::Parms<R> parms = {300, 500};
 
     {
         auto view = buffer->get_buffer_view();
@@ -87,9 +83,7 @@ START_TEST(t_range_count_merge)
     auto shard1 = Shard(buffer1->get_buffer_view());
     auto shard2 = Shard(buffer2->get_buffer_view());
 
-    rc::Parms<R> parms;
-    parms.lower_bound = 150;
-    parms.upper_bound = 500;
+    rc::Parms<R> parms = {150, 500};
 
     size_t result_size = parms.upper_bound - parms.lower_bound + 1 - 200;
 
@@ -128,10 +122,8 @@ START_TEST(t_lower_bound)
 
     auto merged = Shard(shards);
 
-    for (size_t i=100; i<1000; i++) {
-        R r;
-        r.key = i;
-        r.value = i;
+    for (uint32_t i=100; i<1000; i++) {
+        R r = R{i, i};
 
         auto idx = merged.get_lower_bound(i);
 
diff --git a/tests/include/rangequery.h b/tests/include/rangequery.h
index a8a73f7..a3b761e 100644
--- a/tests/include/rangequery.h
+++ b/tests/include/rangequery.h
@@ -39,9 +39,7 @@ 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;
+    rq::Parms<R> parms = {300, 500};
 
     auto state = rq::Query<R, Shard>::get_query_state(&shard, &parms);
     auto result = rq::Query<R, Shard>::query(&shard, state, &parms);
@@ -62,9 +60,7 @@ 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;
+    rq::Parms<R> parms = {300, 500};
 
     {
         auto view = buffer->get_buffer_view();
@@ -92,9 +88,7 @@ START_TEST(t_range_query_merge)
     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;
+    rq::Parms<R> parms = {150, 500};
 
     size_t result_size = parms.upper_bound - parms.lower_bound + 1 - 200;
 
@@ -149,10 +143,8 @@ START_TEST(t_lower_bound)
 
     auto merged = Shard(shards);
 
-    for (size_t i=100; i<1000; i++) {
-        R r;
-        r.key = i;
-        r.value = i;
+    for (uint32_t i=100; i<1000; i++) {
+        R r = R{i, i};
 
         auto idx = merged.get_lower_bound(i);
 
diff --git a/tests/include/shard_standard.h b/tests/include/shard_standard.h
index 55e4c7b..2809d74 100644
--- a/tests/include/shard_standard.h
+++ b/tests/include/shard_standard.h
@@ -150,10 +150,8 @@ START_TEST(t_point_lookup)
         auto view = buffer->get_buffer_view();
 
         for (size_t i=0; i<n; i++) {
-            R r;
             auto rec = view.get(i);
-            r.key = rec->rec.key;
-            r.value = rec->rec.value;
+            R r = {rec->rec.key, rec->rec.value};
 
             auto result = isam.point_lookup(r);
             ck_assert_ptr_nonnull(result);
@@ -174,10 +172,8 @@ START_TEST(t_point_lookup_miss)
     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++) {
-        R r;
-        r.key = i;
-        r.value = i;
+    for (uint32_t i=n + 100; i<2*n; i++) {
+        R r = R{i, i};
 
         auto result = isam.point_lookup(r);
         ck_assert_ptr_null(result);
diff --git a/tests/include/shard_string.h b/tests/include/shard_string.h
index fa51630..2d7a72a 100644
--- a/tests/include/shard_string.h
+++ b/tests/include/shard_string.h
@@ -122,7 +122,7 @@ START_TEST(t_point_lookup)
 
             auto result = shard.point_lookup(r);
             ck_assert_ptr_nonnull(result);
-            ck_assert_str_eq(result->rec.key.c_str(), r.key.c_str());
+            ck_assert_str_eq(result->rec.key, r.key);
             ck_assert_int_eq(result->rec.value, r.value);
             //fprintf(stderr, "%ld\n", i);
         }
@@ -141,9 +141,8 @@ START_TEST(t_point_lookup_miss)
     auto shard = Shard(buffer->get_buffer_view());
 
     for (size_t i=n + 100; i<2*n; i++) {
-        R r;
-        r.key = std::string("computer");
-        r.value = 1234;
+        const char *c = "computer";
+        R r = {c, 1234, 8};
 
         auto result = shard.point_lookup(r);
         ck_assert_ptr_null(result);
diff --git a/tests/include/testing.h b/tests/include/testing.h
index 2315daa..d0bff2d 100644
--- a/tests/include/testing.h
+++ b/tests/include/testing.h
@@ -27,14 +27,17 @@ typedef de::WeightedRecord<uint64_t, uint32_t, uint64_t> WRec;
 typedef de::Record<uint64_t, uint32_t> Rec;
 typedef de::EuclidPoint<uint64_t> PRec;
 
-typedef de::Record<std::string, uint64_t> StringRec;
+typedef de::Record<const char*, uint64_t> StringRec;
 
-std::string kjv_wordlist = "tests/data/kjv-wordlist.txt";
-std::string summa_wordlist = "tests/data/summa-wordlist.txt";
+static std::string kjv_wordlist = "tests/data/kjv-wordlist.txt";
+static std::string summa_wordlist = "tests/data/summa-wordlist.txt";
+
+static std::vector<std::unique_ptr<char[]>> string_data;
 
 static std::vector<StringRec> read_string_data(std::string fname, size_t n) {
     std::vector<StringRec> vec;
     vec.reserve(n);
+    string_data.reserve(n);
 
     std::fstream file;
     file.open(fname, std::ios::in);
@@ -44,13 +47,17 @@ static std::vector<StringRec> read_string_data(std::string fname, size_t n) {
         if (!std::getline(file, line, '\n')) break;
 
         std::stringstream ls(line);
-        StringRec r;
         std::string field;
 
         std::getline(ls, field, '\t');
-        r.value = atol(field.c_str());
+        auto val = atol(field.c_str());
         std::getline(ls, field, '\n');
-        r.key = std::string(field);
+
+        char *c = strdup(field.c_str());
+
+        string_data.push_back(std::unique_ptr<char[]>(c));
+
+        StringRec r(string_data[string_data.size() -1].get(), val, field.size());
         
         vec.push_back(r);
     }
@@ -62,7 +69,7 @@ static std::vector<StringRec> read_string_data(std::string fname, size_t n) {
 template <de::RecordInterface R> 
 std::vector<R> strip_wrapping(std::vector<de::Wrapped<R>> vec) {
     std::vector<R> out(vec.size());
-    for (size_t i=0; i<vec.size(); i++) {
+    for (uint32_t i=0; i<vec.size(); i++) {
         out[i] = vec[i].rec;
     }
 
@@ -115,34 +122,24 @@ static de::MutableBuffer<R> *create_test_mbuffer(size_t cnt)
 {
     auto buffer = new de::MutableBuffer<R>(cnt/2, cnt);
 
-    R rec;
     if constexpr (de::KVPInterface<R>){
-        if constexpr (std::is_same_v<decltype(R::key), std::string>) {
+        if constexpr (std::is_same_v<decltype(R::key), const char*>){
             auto records = read_string_data(kjv_wordlist, cnt);
             for (size_t i=0; i<cnt; i++) {
-                if constexpr (de::WeightedRecordInterface<R>) {
-                    rec.weight = 1;
-                }
-
                 buffer->append(records[i]);
             }
         } else {
             for (size_t i = 0; i < cnt; i++) {
-                rec.key = rand();
-                rec.value = rand();
-
                 if constexpr (de::WeightedRecordInterface<R>) {
-                    rec.weight = 1;
+                    buffer->append({(uint64_t) rand(), (uint32_t) rand(), 1});
+                } else {
+                    buffer->append({(uint64_t) rand(), (uint32_t) rand()});
                 }
-
-                buffer->append(rec);
             }
         }
     } else if constexpr (de::NDRecordInterface<R>) {
         for (size_t i=0; i<cnt; i++) {
-            uint64_t a = rand();
-            uint64_t b = rand();
-            buffer->append({a, b});
+            buffer->append({(uint64_t) rand(), (uint64_t) rand()});
         }
     } 
 
@@ -155,25 +152,19 @@ static de::MutableBuffer<R> *create_sequential_mbuffer(size_t start, size_t stop
     size_t cnt = stop - start;
     auto buffer = new de::MutableBuffer<R>(cnt/2, cnt);
 
-    for (size_t i=start; i<stop; i++) {
-        R rec;
-        if constexpr (de::KVPInterface<R>) {
-            rec.key = i;
-            rec.value = i;
-        } else if constexpr (de::NDRecordInterface<R>) {
-            rec = {i, i};
-        }
+    for (uint32_t i=start; i<stop; i++) {
 
         if constexpr (de::WeightedRecordInterface<R>) {
-            rec.weight = 1;
+            buffer->append({i, i, 1});
+        } else {
+            buffer->append({i, i});
         }
-
-        buffer->append(rec);
     }
 
     return buffer;
 }
 
+/*
 template <de::KVPInterface R>
 static de::MutableBuffer<R> *create_test_mbuffer_tombstones(size_t cnt, size_t ts_cnt) 
 {
@@ -183,13 +174,13 @@ static de::MutableBuffer<R> *create_test_mbuffer_tombstones(size_t cnt, size_t t
 
     R rec;
     for (size_t i = 0; i < cnt; i++) {
-        rec.key = rand();
-        rec.value = rand();
-
         if constexpr (de::WeightedRecordInterface<R>) {
-            rec.weight = 1;
+            rec = {rand(), rand(), 1};
+        } else {
+            rec = {rand(), rand(), 1};
         }
 
+
         if (i < ts_cnt) {
             tombstones.push_back({rec.key, rec.value});
         }
@@ -204,6 +195,7 @@ static de::MutableBuffer<R> *create_test_mbuffer_tombstones(size_t cnt, size_t t
 
     return buffer;
 }
+*/
 
 template <typename R>
 requires de::WeightedRecordInterface<R> && de::KVPInterface<R>
@@ -234,20 +226,12 @@ static de::MutableBuffer<R> *create_double_seq_mbuffer(size_t cnt, bool ts=false
 {
     auto buffer = new de::MutableBuffer<R>(cnt/2, cnt);
 
-    for (size_t i = 0; i < cnt / 2; i++) { 
-        R rec;
-        rec.key = i;
-        rec.value = i;
-
-        buffer->append(rec, ts);
+    for (uint32_t i = 0; i < cnt / 2; i++) { 
+        buffer->append({i, i}, ts);
     }
 
-    for (size_t i = 0; i < cnt / 2; i++) {
-        R rec;
-        rec.key = i;
-        rec.value = i + 1;
-
-        buffer->append(rec, ts);
+    for (uint32_t i = 0; i < cnt / 2; i++) {
+        buffer->append({i, i+1}, ts);
     }
 
     return buffer;
-- 
cgit v1.2.3


From 438feac7e56fee425d9c6f1a43298ff9dc5b71d1 Mon Sep 17 00:00:00 2001
From: Douglas Rumbaugh <dbr4@psu.edu>
Date: Fri, 19 Apr 2024 17:38:16 -0400
Subject: Properly implemented support for iteratively decomposable problems

---
 tests/include/pointlookup.h  | 14 +++++++-------
 tests/include/rangecount.h   |  3 ++-
 tests/include/rangequery.h   |  3 ++-
 tests/include/shard_string.h |  8 ++++----
 tests/include/wirs.h         |  3 ++-
 5 files changed, 17 insertions(+), 14 deletions(-)

(limited to 'tests/include')

diff --git a/tests/include/pointlookup.h b/tests/include/pointlookup.h
index 84e71f2..71a1099 100644
--- a/tests/include/pointlookup.h
+++ b/tests/include/pointlookup.h
@@ -25,15 +25,15 @@
  * include statement.
  */
 
-#include "shard/FSTrie.h"
+//#include "shard/FSTrie.h"
 #include "query/pointlookup.h"
 #include "testing.h"
 
 #include <check.h>
 
 using namespace de;
-typedef StringRec R;
-typedef FSTrie<R> Shard;
+//typedef StringRec R;
+//typedef FSTrie<R> Shard;
 
 START_TEST(t_point_lookup_query)
 {
@@ -51,8 +51,8 @@ START_TEST(t_point_lookup_query)
             pl::Query<R, Shard>::delete_query_state(state);
 
             ck_assert_int_eq(result.size(), 1);
-            ck_assert_str_eq(result[0].rec.key, key);
-            ck_assert_int_eq(result[0].rec.value, bv.get(i)->rec.value);
+            //ck_assert_str_eq(result[0].rec.key, key);
+            //ck_assert_int_eq(result[0].rec.value, bv.get(i)->rec.value);
         }
 
         /* point lookup miss; result size should be 0 */
@@ -85,8 +85,8 @@ START_TEST(t_buffer_point_lookup)
             pl::Query<R, Shard>::delete_buffer_query_state(state);
 
             ck_assert_int_eq(result.size(), 1);
-            ck_assert_str_eq(result[0].rec.key, view.get(i)->rec.key);
-            ck_assert_int_eq(result[0].rec.value, view.get(i)->rec.value);
+            //ck_assert_str_eq(result[0].rec.key, view.get(i)->rec.key);
+            //ck_assert_int_eq(result[0].rec.value, view.get(i)->rec.value);
         }
 
         /* point lookup miss; result size should be 0 */
diff --git a/tests/include/rangecount.h b/tests/include/rangecount.h
index c97d64c..1951221 100644
--- a/tests/include/rangecount.h
+++ b/tests/include/rangecount.h
@@ -100,7 +100,8 @@ START_TEST(t_range_count_merge)
     ck_assert_int_eq(results[0].size(), 1);
     ck_assert_int_eq(results[1].size(), 1);
 
-    auto result = rc::Query<R, Shard>::merge(results, nullptr);
+    std::vector<R> result;
+    rc::Query<R, Shard>::merge(results, nullptr, result);
 
     ck_assert_int_eq(result[0].key, result_size);
 
diff --git a/tests/include/rangequery.h b/tests/include/rangequery.h
index a3b761e..f90e107 100644
--- a/tests/include/rangequery.h
+++ b/tests/include/rangequery.h
@@ -113,7 +113,8 @@ START_TEST(t_range_query_merge)
         }
     }
 
-    auto result = rq::Query<R, Shard>::merge(proc_results, nullptr);
+    std::vector<R> result;
+    rq::Query<R, Shard>::merge(proc_results, nullptr, result);
     std::sort(result.begin(), result.end());
 
     ck_assert_int_eq(result.size(), result_size);
diff --git a/tests/include/shard_string.h b/tests/include/shard_string.h
index 2d7a72a..881f41a 100644
--- a/tests/include/shard_string.h
+++ b/tests/include/shard_string.h
@@ -26,8 +26,8 @@
 #include "testing.h"
 #include <check.h>
 using namespace de;
-typedef StringRec R;
-typedef FSTrie<R> Shard;
+//typedef StringRec R;
+//typedef FSTrie<R> Shard;
 
 START_TEST(t_mbuffer_init)
 {
@@ -122,8 +122,8 @@ START_TEST(t_point_lookup)
 
             auto result = shard.point_lookup(r);
             ck_assert_ptr_nonnull(result);
-            ck_assert_str_eq(result->rec.key, r.key);
-            ck_assert_int_eq(result->rec.value, r.value);
+            //ck_assert_str_eq(result->rec.key, r.key);
+            //ck_assert_int_eq(result->rec.value, r.value);
             //fprintf(stderr, "%ld\n", i);
         }
     }
diff --git a/tests/include/wirs.h b/tests/include/wirs.h
index 90cd22d..4c0630f 100644
--- a/tests/include/wirs.h
+++ b/tests/include/wirs.h
@@ -117,7 +117,8 @@ START_TEST(t_range_query_merge)
         }
     }
 
-    auto result = rq::Query<R, Shard>::merge(proc_results, nullptr);
+    std::vector<R> result;
+    rq::Query<R, Shard>::merge(proc_results, nullptr, result);
     std::sort(result.begin(), result.end());
 
     ck_assert_int_eq(result.size(), result_size);
-- 
cgit v1.2.3