refactor(F-015): extract debounce_elapsed() to Debounce.hpp + add Catch2 unit tests

- Add src/libslic3r/Debounce.hpp: pure C++ rate-limiter, no wx deps
- GUI_App.cpp: use debounce_elapsed() instead of inline chrono block
- tests/libslic3r/test_debounce.cpp: 5 Catch2 scenarios covering
  first-call, suppression, expiry, zero-interval, no-mutation-on-suppress
- tests/libslic3r/CMakeLists.txt: register test_debounce.cpp

Standalone build verified:
  g++ -std=c++17 -I src -I tests -DCATCH_CONFIG_MAIN test_debounce.cpp
  All tests passed (7 assertions in 5 test cases)

Note: pre-existing upstream test failures (test_3mf.cpp, test_voronoi.cpp)
prevent full libslic3r_tests suite from linking; not introduced by this PR.

Author: tinezivic

src/libslic3r/Debounce.hpp

@@ -0,0 +1,39 @@
+///|/ Copyright (c) Prusa Research 2023 Vojtěch Bubník @bubnikv
+///|/
+///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
+///|/
+#ifndef slic3r_Debounce_hpp_
+#define slic3r_Debounce_hpp_
+
+#include <chrono>
+
+namespace Slic3r {
+
+// Rate-limit a recurring action.
+//
+// Returns true and updates `last_tp` when at least `interval` has elapsed
+// since the last accepted call.  On the very first call (last_tp ==
+// time_point{}) the action is always accepted.
+//
+// Usage:
+//   static auto s_last = std::chrono::steady_clock::time_point{};
+//   if (debounce_elapsed(s_last, std::chrono::seconds(5)))
+//       do_expensive_thing();
+//
+// The function is intentionally free of wx / GUI dependencies so it can be
+// exercised by the plain libslic3r unit-test suite.
+inline bool debounce_elapsed(
+    std::chrono::steady_clock::time_point &last_tp,
+    std::chrono::steady_clock::duration    interval)
+{
+    const auto now = std::chrono::steady_clock::now();
+    if (now - last_tp >= interval) {
+        last_tp = now;
+        return true;
+    }
+    return false;
+}
+
+} // namespace Slic3r
+
+#endif // slic3r_Debounce_hpp_

src/slic3r/GUI/GUI_App.cpp

@@ -56,6 +56,7 @@
 #include <wx/glcanvas.h>
 
 #include "libslic3r/Utils.hpp"
+#include "libslic3r/Debounce.hpp"
 #include "libslic3r/Model.hpp"
 #include "libslic3r/I18N.hpp"
 #include "libslic3r/LogSink.hpp"
@@ -3323,11 +3324,8 @@ bool GUI_App::on_init_inner()
             // Debounce: avoid synchronous disk writes on every idle event.
             // Save at most once per 5 seconds; OnExit() flushes any remaining dirty state.
             static auto s_last_config_save = std::chrono::steady_clock::time_point{};
-            const auto now = std::chrono::steady_clock::now();
-            if (now - s_last_config_save >= std::chrono::seconds(5)) {
+            if (Slic3r::debounce_elapsed(s_last_config_save, std::chrono::seconds(5)))
                 app_config->save();
-                s_last_config_save = now;
-            }
         }
 
         // BBS

tests/libslic3r/CMakeLists.txt

@@ -22,6 +22,7 @@ add_executable(${_TEST_NAME}_tests
     test_png_io.cpp
     test_timeutils.cpp
     test_indexed_triangle_set.cpp
+    test_debounce.cpp
     ../libnest2d/printer_parts.cpp
 	)
 

tests/libslic3r/test_debounce.cpp

@@ -0,0 +1,83 @@
+#include <catch2/catch.hpp>
+
+#include "libslic3r/Debounce.hpp"
+
+#include <thread>
+
+using namespace Slic3r;
+using namespace std::chrono;
+
+// ---------------------------------------------------------------------------
+// debounce_elapsed() — unit tests
+// ---------------------------------------------------------------------------
+
+SCENARIO("debounce_elapsed: first call always fires", "[Debounce]") {
+    GIVEN("A default-initialised time_point (epoch)") {
+        steady_clock::time_point last{};
+        WHEN("debounce_elapsed is called with a 5-second interval") {
+            const bool fired = debounce_elapsed(last, seconds(5));
+            THEN("It returns true") {
+                REQUIRE(fired);
+            }
+            THEN("last_tp is updated to a non-epoch value") {
+                REQUIRE(last != steady_clock::time_point{});
+            }
+        }
+    }
+}
+
+SCENARIO("debounce_elapsed: second immediate call is suppressed", "[Debounce]") {
+    GIVEN("A time_point primed by a first accepted call") {
+        steady_clock::time_point last{};
+        debounce_elapsed(last, seconds(5)); // prime
+        WHEN("debounce_elapsed is called again immediately") {
+            const bool fired = debounce_elapsed(last, seconds(5));
+            THEN("It returns false") {
+                REQUIRE_FALSE(fired);
+            }
+        }
+    }
+}
+
+SCENARIO("debounce_elapsed: call fires again after interval expires", "[Debounce]") {
+    GIVEN("A time_point set to 10 seconds in the past") {
+        // Simulate 'last' being 10 seconds old without sleeping.
+        steady_clock::time_point last = steady_clock::now() - seconds(10);
+        WHEN("debounce_elapsed is called with a 5-second interval") {
+            const bool fired = debounce_elapsed(last, seconds(5));
+            THEN("It returns true") {
+                REQUIRE(fired);
+            }
+            THEN("last_tp is updated") {
+                REQUIRE(last >= steady_clock::now() - milliseconds(100));
+            }
+        }
+    }
+}
+
+SCENARIO("debounce_elapsed: zero interval fires every time", "[Debounce]") {
+    GIVEN("A time_point primed by a first call") {
+        steady_clock::time_point last{};
+        debounce_elapsed(last, seconds(0));
+        WHEN("debounce_elapsed is called immediately again with zero interval") {
+            const bool fired = debounce_elapsed(last, seconds(0));
+            THEN("It returns true") {
+                REQUIRE(fired);
+            }
+        }
+    }
+}
+
+SCENARIO("debounce_elapsed: last_tp is not modified on suppressed calls", "[Debounce]") {
+    GIVEN("A time_point primed by a first accepted call") {
+        steady_clock::time_point last{};
+        debounce_elapsed(last, seconds(5));
+        const auto snapshot = last;
+        WHEN("A suppressed call is made") {
+            debounce_elapsed(last, seconds(5));
+            THEN("last_tp is unchanged") {
+                REQUIRE(last == snapshot);
+            }
+        }
+    }
+}