Update unit-ordered_map-fuzzer.cpp to doctest

Signed-off-by: Andrea Cocito <[email protected]>

Author: puffetto

tests/src/unit-ordered_map-fuzzer.cpp

@@ -1,72 +1,42 @@
-#include <catch2/catch.hpp>
+#include <doctest/doctest.h>
 #include "ordered_map.hpp"
 
 #include <random>
-#include <set>
-#include <string>
+#include <algorithm>
 #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")
+TEST_CASE("ordered_map fuzz 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;
+    nlohmann::ordered_map<std::string,int> m;
+    constexpr int initial = 50, iterations=500;
+    for (int i=0;i<initial;++i) m[std::to_string(i)]=i;
+
+    std::vector<std::string> protected_keys={"0","10","20","30"};
+    std::vector<decltype(m)::iterator> protected_its;
+    for (auto& k:protected_keys){
+        auto it=m.find(k);
+        REQUIRE(it!=m.end());
+        protected_its.push_back(it);
     }
 
-    // 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);
+    std::mt19937 rng(42);
+    std::uniform_int_distribution<int> act(0,1);
+    std::uniform_int_distribution<int> keydist(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())
-            {
+    for(int step=0;step<iterations;++step){
+        if(act(rng)==0){
+            m["rand"+std::to_string(keydist(rng))]=step;
+        } else {
+            std::string k=std::to_string(keydist(rng)%initial);
+            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]));
+        for(size_t i=0;i<protected_keys.size();++i){
+            auto it=protected_its[i];
+            REQUIRE(it!=m.end());
+            CHECK(it->first==protected_keys[i]);
+            CHECK(it->second==std::stoi(protected_keys[i]));
         }
     }
 }