Create unit-ordered_map-fuzzer.cpp

Another unit test for stress-testing ordered_map

Signed-off-by: Andrea Cocito <39852324+puffetto@users.noreply.github.com>

Author: puffetto

tests/src/unit-ordered_map-fuzzer.cpp

@@ -0,0 +1,72 @@
+#include <catch2/catch.hpp>
+#include "ordered_map.hpp"
+
+#include <random>
+#include <set>
+#include <string>
+#include <vector>
+
+using nlohmann::ordered_map;
+
+// (Previous test cases remain unchanged...)
+// See previous message for all the basic/consistency/stability tests.
+
+// ------------------------------------------------------------------
+// Randomized stress test for iterator stability
+// ------------------------------------------------------------------
+
+TEST_CASE("ordered_map randomized iterator stability stress test")
+{
+    constexpr int initial_keys = 20;
+    constexpr int iterations   = 200;
+
+    ordered_map<std::string, int> m;
+
+    // insert initial keys
+    for (int i = 0; i < initial_keys; ++i)
+    {
+        m[std::to_string(i)] = i;
+    }
+
+    // pick a few "protected" keys to keep iterators to
+    std::vector<std::string> protected_keys = {"0", "5", "10", "15"};
+    std::vector<ordered_map<std::string,int>::iterator> protected_iterators;
+    for (auto& k : protected_keys)
+    {
+        auto it = m.find(k);
+        REQUIRE(it != m.end());
+        protected_iterators.push_back(it);
+    }
+
+    std::mt19937 rng(12345); // fixed seed for reproducibility
+    std::uniform_int_distribution<int> action(0, 1); // 0=insert, 1=erase
+    std::uniform_int_distribution<int> keygen(0, 1000);
+
+    for (int step = 0; step < iterations; ++step)
+    {
+        if (action(rng) == 0)
+        {
+            // random insert
+            std::string k = "k" + std::to_string(keygen(rng));
+            m[k] = step;
+        }
+        else
+        {
+            // random erase, but never erase protected keys
+            std::string k = std::to_string(keygen(rng) % initial_keys);
+            if (std::find(protected_keys.begin(), protected_keys.end(), k) == protected_keys.end())
+            {
+                m.erase(k);
+            }
+        }
+
+        // after each op, check protected iterators still valid
+        for (size_t i = 0; i < protected_keys.size(); ++i)
+        {
+            auto it = protected_iterators[i];
+            REQUIRE(it != m.end());
+            CHECK(it->first == protected_keys[i]);
+            CHECK(it->second == std::stoi(protected_keys[i]));
+        }
+    }
+}