diff --git a/test/fd/atomic.cpp b/test/fd/atomic.cpp
index c67ce41..b49112c 100644
--- a/test/fd/atomic.cpp
+++ b/test/fd/atomic.cpp
@@ -1,8 +1,9 @@
-#include <filesystem>
-#include <memory>
 #include <stdplus/fd/atomic.hpp>
 #include <stdplus/fd/ops.hpp>
 #include <stdplus/gtest/tmp.hpp>
+
+#include <filesystem>
+#include <memory>
 #include <string_view>
 
 namespace stdplus
@@ -18,9 +19,7 @@
     std::string filename;
     std::unique_ptr<AtomicWriter> file;
 
-    AtomicWriterTest() : filename(fmt::format("{}/out", CaseTmpDir()))
-    {
-    }
+    AtomicWriterTest() : filename(fmt::format("{}/out", CaseTmpDir())) {}
 
     ~AtomicWriterTest() noexcept
     {
@@ -47,8 +46,8 @@
 TEST_F(AtomicWriterTest, BadCommit)
 {
     auto tmp = fmt::format("{}/tmp.XXXXXX", CaseTmpDir());
-    ASSERT_NO_THROW(file =
-                        std::make_unique<AtomicWriter>("/dev/null", 0644, tmp));
+    ASSERT_NO_THROW(
+        file = std::make_unique<AtomicWriter>("/dev/null", 0644, tmp));
     writeExact(*file, "hi\n"sv);
     EXPECT_TRUE(std::filesystem::exists(file->getTmpname()));
     EXPECT_THROW(file->commit(), std::filesystem::filesystem_error);
