Keep the Config Dirty After a Failed Write and Sweep a Write's Own Leftovers

Before this change a config whose temporary could not be written stayed
dirty, so the idle handler tried again; the last round cleared the flag
regardless, which lost a pending change to a transient failure. The
writer reports whether the config itself was written and the flag clears
only then, as it always did.

The Windows rename retry duplicated what WindowsSupport::rename already
does, retrying and moving an open destination aside, and multiplied its
error logging; it is gone. The file a refused rename moves aside is
named so the sweep can clear it after a crash in between, and every
successful atomic write sweeps leftovers of earlier writes to the same
target, so the caches and the smaller state files are covered too; the
name shapes are strict enough that nothing of the user's matches.

The lock wait defaults to a second, long against a critical section of
milliseconds and short against the GUI thread; a lock file that cannot
be opened says to check its owner and permissions; the test timing
bounds tolerate a loaded runner; and the helper's header includes what
its declarations use.

tests/libslic3r/test_instance_lock.cpp

@@ -32,7 +32,8 @@ TEST_CASE("InstanceLock creates its lock file and holds it for the guard's scope
     const auto   started = std::chrono::steady_clock::now();
     InstanceLock again(path, 5000ms);
     REQUIRE(again.locked());
-    REQUIRE(std::chrono::steady_clock::now() - started < 1000ms);
+    // Well inside the timeout it would otherwise have waited out; loose enough for a loaded runner.
+    REQUIRE(std::chrono::steady_clock::now() - started < 4000ms);
 }
 
 TEST_CASE("InstanceLock nests within one thread", "[InstanceLock]")
@@ -193,7 +194,7 @@ TEST_CASE("InstanceLock yields to another process and reports it", "[InstanceLoc
 
     REQUIRE_FALSE(locked_while_child_holds);
     REQUIRE_FALSE(locked_during_cooldown);
-    REQUIRE(cooldown_wait < 1000ms);
+    REQUIRE(cooldown_wait < 4000ms);
     // A guard inside the cool-down still takes the lock when it is free.
     InstanceLock lock(path);
     REQUIRE(lock.locked());

tests/libslic3r/test_utils.cpp

@@ -189,7 +189,7 @@ TEST_CASE("write_file_atomically survives two threads writing one target", "[uti
 
 TEST_CASE("remove_stale_temp_files removes only old <name>.<pid>.<n>.tmp files", "[utils]") {
     ScopedTemporaryDir dir;
-    for (const char *name : { "a.json.123.7.tmp", "b.info.4.0.tmp", "c.json", "d.tmp", "e.json.x.1.tmp", "f.json..tmp", "a.json.99", "a.json.12.tmp" }) {
+    for (const char *name : { "a.json.123.7.tmp", "b.info.4.0.tmp", "c.json", "d.tmp", "e.json.x.1.tmp", "f.json..tmp", "a.json.99", "a.json.12.tmp", "a.json.123.old", "h.json.old" }) {
         REQUIRE_FALSE(write_file_atomically((dir.path() / name).string(), "x"));
         // An hour old: long past the age below which a temporary may still be in flight.
         boost::filesystem::last_write_time(dir.path() / name, std::time(nullptr) - 3600);
@@ -198,20 +198,22 @@ TEST_CASE("remove_stale_temp_files removes only old <name>.<pid>.<n>.tmp files",
     REQUIRE_FALSE(write_file_atomically((dir.path() / "g.json.7.2.tmp").string(), "x"));
 
     SECTION("with a name prefix only matching names go; a numbered backup or a one-segment name is not a temporary") {
-        REQUIRE(remove_stale_temp_files(dir.path(), "a.json") == 1);
+        REQUIRE(remove_stale_temp_files(dir.path(), "a.json") == 2);
         REQUIRE_FALSE(boost::filesystem::exists(dir.path() / "a.json.123.7.tmp"));
+        REQUIRE_FALSE(boost::filesystem::exists(dir.path() / "a.json.123.old"));
         REQUIRE(boost::filesystem::exists(dir.path() / "a.json.99"));
         REQUIRE(boost::filesystem::exists(dir.path() / "a.json.12.tmp"));
         REQUIRE(boost::filesystem::exists(dir.path() / "b.info.4.0.tmp"));
     }
     SECTION("without a prefix every stale temporary goes and nothing else") {
-        REQUIRE(remove_stale_temp_files(dir.path()) == 2);
+        REQUIRE(remove_stale_temp_files(dir.path()) == 3);
         size_t entries = 0;
         for (auto &entry : boost::filesystem::directory_iterator(dir.path())) {
             (void) entry;
             ++entries;
         }
-        REQUIRE(entries == 7);
+        REQUIRE(entries == 8);
+        REQUIRE(boost::filesystem::exists(dir.path() / "h.json.old"));
         REQUIRE(boost::filesystem::exists(dir.path() / "a.json.99"));
         REQUIRE(boost::filesystem::exists(dir.path() / "g.json.7.2.tmp"));
     }