diff --git a/.clang-format b/.clang-format
index 9109e65..d92a3f1 100644
--- a/.clang-format
+++ b/.clang-format
@@ -5,22 +5,24 @@
 AlignAfterOpenBracket: Align
 AlignConsecutiveAssignments: false
 AlignConsecutiveDeclarations: false
-AlignEscapedNewlinesLeft: false
-AlignOperands:   true
-AlignTrailingComments: true
+AlignEscapedNewlines: Right
+AlignOperands:  Align
+AlignTrailingComments:
+  Kind: Always
+  OverEmptyLines: 1
 AllowAllParametersOfDeclarationOnNextLine: true
-AllowShortBlocksOnASingleLine: false
+AllowShortBlocksOnASingleLine: Empty
 AllowShortCaseLabelsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: None
+AllowShortFunctionsOnASingleLine: Empty
 AllowShortIfStatementsOnASingleLine: false
 AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterDefinitionReturnType: None
 AlwaysBreakAfterReturnType: None
 AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: true
+AlwaysBreakTemplateDeclarations: Yes
 BinPackArguments: true
 BinPackParameters: true
 BraceWrapping:
+  AfterCaseLabel:  true
   AfterClass:      true
   AfterControlStatement: true
   AfterEnum:       true
@@ -29,29 +31,60 @@
   AfterObjCDeclaration: true
   AfterStruct:     true
   AfterUnion:      true
+  AfterExternBlock: true
   BeforeCatch:     true
   BeforeElse:      true
   IndentBraces:    false
+  SplitEmptyFunction:   false
+  SplitEmptyRecord:     false
+  SplitEmptyNamespace:  false
+BreakAfterAttributes: Never
 BreakBeforeBinaryOperators: None
 BreakBeforeBraces: Custom
 BreakBeforeTernaryOperators: true
 BreakConstructorInitializers: AfterColon
+BreakInheritanceList: AfterColon
+BreakStringLiterals: false
 ColumnLimit:     80
 CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
 ConstructorInitializerAllOnOneLineOrOnePerLine: false
 ConstructorInitializerIndentWidth: 4
 ContinuationIndentWidth: 4
 Cpp11BracedListStyle: true
+DeriveLineEnding: false
 DerivePointerAlignment: false
 PointerAlignment: Left
 DisableFormat:   false
 ExperimentalAutoDetectBinPacking: false
 FixNamespaceComments: true
 ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
+IncludeBlocks: Regroup
+IncludeCategories:
+  - Regex:           '^[<"](gtest|gmock)'
+    Priority:        7
+  - Regex:           '^"config.h"'
+    Priority:        -1
+  - Regex:           '^".*\.h"'
+    Priority:        1
+  - Regex:           '^".*\.hpp"'
+    Priority:        2
+  - Regex:           '^<.*\.h>'
+    Priority:        3
+  - Regex:           '^<.*\.hpp>'
+    Priority:        4
+  - Regex:           '^<.*'
+    Priority:        5
+  - Regex:           '.*'
+    Priority:        6
 IndentCaseLabels: true
+IndentRequiresClause: true
 IndentWidth:     4
 IndentWrappedFunctionNames: true
-KeepEmptyLinesAtTheStartOfBlocks: true
+InsertNewlineAtEOF: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+LambdaBodyIndentation: OuterScope
+LineEnding: LF
 MacroBlockBegin: ''
 MacroBlockEnd:   ''
 MaxEmptyLinesToKeep: 1
@@ -59,18 +92,29 @@
 ObjCBlockIndentWidth: 2
 ObjCSpaceAfterProperty: false
 ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 25
 PenaltyBreakBeforeFirstCallParameter: 19
 PenaltyBreakComment: 300
 PenaltyBreakFirstLessLess: 120
 PenaltyBreakString: 1000
 PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 60
+PenaltyIndentedWhitespace: 0
+QualifierAlignment: Left
+ReferenceAlignment: Left
 ReflowComments:  true
+RequiresClausePosition: OwnLine
+RequiresExpressionIndentation: Keyword
 SortIncludes:    true
 SortUsingDeclarations: true
 SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
 SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
 SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
 SpaceInEmptyParentheses: false
 SpacesBeforeTrailingComments: 1
 SpacesInAngles:  false
@@ -78,7 +122,7 @@
 SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
-Standard:        Cpp11
+Standard:        Latest
 TabWidth:        4
 UseTab:          Never
 ...
diff --git a/include-dl/stdplus/dl.hpp b/include-dl/stdplus/dl.hpp
index 0526391..24044c1 100644
--- a/include-dl/stdplus/dl.hpp
+++ b/include-dl/stdplus/dl.hpp
@@ -28,13 +28,11 @@
   public:
     inline DlOpenFlags(DlOpenType type) :
         BitFlags<int, DlOpenFlag>(static_cast<int>(type))
-    {
-    }
+    {}
 
     inline DlOpenFlags(BitFlags<int, DlOpenFlag> flags) :
         BitFlags<int, DlOpenFlag>(flags)
-    {
-    }
+    {}
 };
 
 class Dl
diff --git a/include-fd/stdplus/fd/atomic.hpp b/include-fd/stdplus/fd/atomic.hpp
index 904e706..389c5ac 100644
--- a/include-fd/stdplus/fd/atomic.hpp
+++ b/include-fd/stdplus/fd/atomic.hpp
@@ -1,6 +1,7 @@
 #pragma once
-#include <filesystem>
 #include <stdplus/fd/managed.hpp>
+
+#include <filesystem>
 #include <string>
 #include <string_view>
 
diff --git a/include-fd/stdplus/fd/create.hpp b/include-fd/stdplus/fd/create.hpp
index 83aa2ba..e993739 100644
--- a/include-fd/stdplus/fd/create.hpp
+++ b/include-fd/stdplus/fd/create.hpp
@@ -1,8 +1,10 @@
 #pragma once
 #include <fcntl.h>
 #include <netinet/ip.h>
+
 #include <stdplus/fd/dupable.hpp>
 #include <stdplus/flags.hpp>
+
 #include <string>
 
 namespace stdplus
@@ -43,13 +45,11 @@
   public:
     inline OpenFlags(OpenAccess access) :
         BitFlags<int, OpenFlag>(static_cast<int>(access))
-    {
-    }
+    {}
 
     inline OpenFlags(BitFlags<int, OpenFlag> flags) :
         BitFlags<int, OpenFlag>(flags)
-    {
-    }
+    {}
 };
 
 DupableFd open(const char* pathname, OpenFlags flags, mode_t mode = 0);
diff --git a/include-fd/stdplus/fd/fmt.hpp b/include-fd/stdplus/fd/fmt.hpp
index de77b68..faa8dfc 100644
--- a/include-fd/stdplus/fd/fmt.hpp
+++ b/include-fd/stdplus/fd/fmt.hpp
@@ -1,7 +1,9 @@
 #pragma once
 #include <fmt/format.h>
-#include <functional>
+
 #include <stdplus/fd/intf.hpp>
+
+#include <functional>
 #include <type_traits>
 #include <utility>
 
diff --git a/include-fd/stdplus/fd/gmock.hpp b/include-fd/stdplus/fd/gmock.hpp
index ca3b2af..7b70fd8 100644
--- a/include-fd/stdplus/fd/gmock.hpp
+++ b/include-fd/stdplus/fd/gmock.hpp
@@ -1,7 +1,8 @@
 #pragma once
-#include <gmock/gmock.h>
 #include <stdplus/fd/intf.hpp>
 
+#include <gmock/gmock.h>
+
 namespace stdplus
 {
 namespace fd
diff --git a/include-fd/stdplus/fd/intf.hpp b/include-fd/stdplus/fd/intf.hpp
index 4d9553d..479fcc0 100644
--- a/include-fd/stdplus/fd/intf.hpp
+++ b/include-fd/stdplus/fd/intf.hpp
@@ -1,11 +1,13 @@
 #pragma once
-#include <cstddef>
 #include <fcntl.h>
-#include <optional>
-#include <span>
-#include <stdplus/flags.hpp>
 #include <sys/mman.h>
 #include <sys/socket.h>
+
+#include <stdplus/flags.hpp>
+
+#include <cstddef>
+#include <optional>
+#include <span>
 #include <tuple>
 
 namespace stdplus
@@ -104,13 +106,11 @@
   public:
     inline MMapFlags(MMapAccess access) :
         BitFlags<int, MMapFlag>(static_cast<int>(access))
-    {
-    }
+    {}
 
     inline MMapFlags(BitFlags<int, MMapFlag> flags) :
         BitFlags<int, MMapFlag>(flags)
-    {
-    }
+    {}
 };
 
 class MMap;
diff --git a/include-fd/stdplus/fd/line.hpp b/include-fd/stdplus/fd/line.hpp
index e8f4b99..994777a 100644
--- a/include-fd/stdplus/fd/line.hpp
+++ b/include-fd/stdplus/fd/line.hpp
@@ -1,8 +1,9 @@
 #pragma once
+#include <stdplus/fd/intf.hpp>
+
 #include <array>
 #include <functional>
 #include <span>
-#include <stdplus/fd/intf.hpp>
 #include <string>
 
 namespace stdplus
diff --git a/include-fd/stdplus/fd/mmap.hpp b/include-fd/stdplus/fd/mmap.hpp
index 06b7944..2250ac0 100644
--- a/include-fd/stdplus/fd/mmap.hpp
+++ b/include-fd/stdplus/fd/mmap.hpp
@@ -1,9 +1,10 @@
 #pragma once
+#include <stdplus/fd/intf.hpp>
+#include <stdplus/handle/managed.hpp>
+
 #include <cstddef>
 #include <functional>
 #include <span>
-#include <stdplus/fd/intf.hpp>
-#include <stdplus/handle/managed.hpp>
 
 namespace stdplus
 {
@@ -19,8 +20,7 @@
             fd,
             std::span<std::byte>{static_cast<std::byte*>(nullptr), window_size},
             prot, flags, offset)
-    {
-    }
+    {}
     MMap(Fd& fd, std::span<std::byte> window, ProtFlags prot, MMapFlags flags,
          off_t offset);
 
diff --git a/include-fd/stdplus/fd/ops.hpp b/include-fd/stdplus/fd/ops.hpp
index c51b2ef..98bdaee 100644
--- a/include-fd/stdplus/fd/ops.hpp
+++ b/include-fd/stdplus/fd/ops.hpp
@@ -1,9 +1,10 @@
 #pragma once
-#include <span>
-#include <stdexcept>
 #include <stdplus/fd/dupable.hpp>
 #include <stdplus/fd/intf.hpp>
 #include <stdplus/raw.hpp>
+
+#include <span>
+#include <stdexcept>
 #include <utility>
 
 namespace stdplus
diff --git a/include/stdplus/cancel.hpp b/include/stdplus/cancel.hpp
index b8bc82d..3017e1b 100644
--- a/include/stdplus/cancel.hpp
+++ b/include/stdplus/cancel.hpp
@@ -30,24 +30,19 @@
 
 struct Cancel : detail::CancelHandle
 {
-    Cancel() : detail::CancelHandle(std::nullopt)
-    {
-    }
+    Cancel() : detail::CancelHandle(std::nullopt) {}
     template <typename T>
     explicit Cancel(T&& t) : detail::CancelHandle(t)
-    {
-    }
+    {}
 };
 
 namespace detail
 {
 
 struct fAny
-{
-};
+{};
 struct fPtr : fAny
-{
-};
+{};
 
 template <typename>
 struct validator
@@ -83,14 +78,12 @@
     template <typename Fi, typename... Vs>
     explicit AlwaysCallOnce(Fi&& fi, Vs&&... default_args) :
         f(std::forward<Fi>(fi)), default_args(std::forward<Vs>(default_args)...)
-    {
-    }
+    {}
     AlwaysCallOnce(const AlwaysCallOnce&) = delete;
     AlwaysCallOnce(AlwaysCallOnce&& other) noexcept :
         f(std::move(other.f)), default_args(std::move(other.default_args)),
         called(std::exchange(other.called, true))
-    {
-    }
+    {}
     AlwaysCallOnce& operator=(const AlwaysCallOnce&) = delete;
     AlwaysCallOnce& operator=(AlwaysCallOnce&& other) noexcept
     {
diff --git a/include/stdplus/exception.hpp b/include/stdplus/exception.hpp
index 5390320..059f17f 100644
--- a/include/stdplus/exception.hpp
+++ b/include/stdplus/exception.hpp
@@ -1,5 +1,6 @@
 #pragma once
 #include <fmt/format.h>
+
 #include <source_location>
 #include <system_error>
 #include <utility>
@@ -40,25 +41,25 @@
 {
     return
         [f = std::move(f), file, line, func](auto&&... args) mutable noexcept {
-            try
-            {
-                return f(std::forward<decltype(args)>(args)...);
-            }
-            catch (const std::exception& e)
-            {
-                fmt::print(stderr, "Ignoring({}:{} {}): {}\n", file, line, func,
-                           e.what());
-            }
-            catch (...)
-            {
-                fmt::print(stderr, "Ignoring({}:{} {}): Invalid Error\n", file,
-                           line, func);
-            }
-            using Ret = std::invoke_result_t<decltype(f), decltype(args)...>;
-            if constexpr (!std::is_same_v<void, Ret>)
-            {
-                return Ret();
-            }
+        try
+        {
+            return f(std::forward<decltype(args)>(args)...);
+        }
+        catch (const std::exception& e)
+        {
+            fmt::print(stderr, "Ignoring({}:{} {}): {}\n", file, line, func,
+                       e.what());
+        }
+        catch (...)
+        {
+            fmt::print(stderr, "Ignoring({}:{} {}): Invalid Error\n", file,
+                       line, func);
+        }
+        using Ret = std::invoke_result_t<decltype(f), decltype(args)...>;
+        if constexpr (!std::is_same_v<void, Ret>)
+        {
+            return Ret();
+        }
         };
 }
 
@@ -79,8 +80,7 @@
             return f(std::forward<decltype(args)>(args)...);
         }
         catch (...)
-        {
-        }
+        {}
         using Ret = std::invoke_result_t<decltype(f), decltype(args)...>;
         if constexpr (!std::is_same_v<void, Ret>)
         {
diff --git a/include/stdplus/flags.hpp b/include/stdplus/flags.hpp
index 047c776..a5678f3 100644
--- a/include/stdplus/flags.hpp
+++ b/include/stdplus/flags.hpp
@@ -8,9 +8,7 @@
 class BitFlags
 {
   public:
-    inline explicit BitFlags(Int val = 0) noexcept : val(val)
-    {
-    }
+    inline explicit BitFlags(Int val = 0) noexcept : val(val) {}
 
     inline BitFlags& set(Flag flag) & noexcept
     {
diff --git a/include/stdplus/handle/copyable.hpp b/include/stdplus/handle/copyable.hpp
index 86fc8b7..c40b432 100644
--- a/include/stdplus/handle/copyable.hpp
+++ b/include/stdplus/handle/copyable.hpp
@@ -1,6 +1,7 @@
 #pragma once
-#include <optional>
 #include <stdplus/handle/managed.hpp>
+
+#include <optional>
 #include <type_traits>
 #include <utility>
 
@@ -57,14 +58,12 @@
                                                            T>&&>(),
                                                    std::declval<Vs>()...))) :
             MHandleF(std::move(maybeV), std::forward<Vs>(vs)...)
-        {
-        }
+        {}
         template <typename... Vs>
         constexpr explicit HandleF(T&& maybeV, Vs&&... vs) noexcept(
             noexcept(MHandleF(std::declval<T&&>(), std::declval<Vs>()...))) :
             MHandleF(std::move(maybeV), std::forward<Vs>(vs)...)
-        {
-        }
+        {}
 
         constexpr HandleF(const HandleF& other) noexcept(noexcept(MHandleF(
             std::nullopt,
@@ -81,8 +80,7 @@
         constexpr HandleF(HandleF&& other) noexcept(
             std::is_nothrow_move_constructible_v<MHandleF>) :
             MHandleF(std::move(other))
-        {
-        }
+        {}
 
         constexpr HandleF& operator=(const HandleF& other) noexcept(
             noexcept(std::declval<HandleF>().reset()) &&
diff --git a/include/stdplus/handle/managed.hpp b/include/stdplus/handle/managed.hpp
index 08cac4f..1d4eceb 100644
--- a/include/stdplus/handle/managed.hpp
+++ b/include/stdplus/handle/managed.hpp
@@ -31,7 +31,6 @@
 template <typename T, typename... As>
 struct Managed
 {
-
     template <typename Drop>
     class HandleF
     {
@@ -50,16 +49,14 @@
                 std::tuple<As...>(std::declval<Vs>()...))) :
             as(std::forward<Vs>(vs)...),
             maybeT(std::move(maybeV))
-        {
-        }
+        {}
         template <typename... Vs>
         constexpr explicit HandleF(T&& maybeV, Vs&&... vs) noexcept(
             std::is_nothrow_move_constructible_v<std::optional<T>>&& noexcept(
                 std::tuple<As...>(std::declval<Vs>()...))) :
             as(std::forward<Vs>(vs)...),
             maybeT(std::move(maybeV))
-        {
-        }
+        {}
 
         HandleF(const HandleF& other) = delete;
         HandleF& operator=(const HandleF& other) = delete;
diff --git a/include/stdplus/pinned.hpp b/include/stdplus/pinned.hpp
index c1490b2..e52a57f 100644
--- a/include/stdplus/pinned.hpp
+++ b/include/stdplus/pinned.hpp
@@ -49,8 +49,7 @@
     constexpr Pinned(Args&&... args) noexcept(
         noexcept(CT(std::declval<Args>()...))) :
         CT(std::forward<Args>(args)...)
-    {
-    }
+    {}
 
     template <typename Arg>
     constexpr Pinned& operator=(Arg&& arg) noexcept(
@@ -76,24 +75,20 @@
                       !std::is_move_assignable_v<std::remove_cvref_t<U>>,
                   bool> = true>
     constexpr PinnedRef(U& u) noexcept : wrapper(u)
-    {
-    }
+    {}
 
     template <typename U>
     constexpr PinnedRef(Pinned<U>& u) noexcept : wrapper(u)
-    {
-    }
+    {}
     template <typename U,
               std::enable_if_t<!std::is_same_v<U, void> && std::is_const_v<T>,
                                bool> = true>
     constexpr PinnedRef(const Pinned<U>& u) noexcept : wrapper(u)
-    {
-    }
+    {}
 
     template <typename U>
     constexpr PinnedRef(PinnedRef<U> u) noexcept : wrapper(u)
-    {
-    }
+    {}
 };
 
 template <typename T>
diff --git a/include/stdplus/raw.hpp b/include/stdplus/raw.hpp
index a5206c0..dbec33e 100644
--- a/include/stdplus/raw.hpp
+++ b/include/stdplus/raw.hpp
@@ -1,6 +1,7 @@
 #pragma once
-#include <algorithm>
 #include <fmt/format.h>
+
+#include <algorithm>
 #include <span>
 #include <stdexcept>
 #include <string_view>
@@ -94,11 +95,9 @@
 /** @brief If you can guarantee the underlying data is properly aligned
  *  for raw struct access this specifier is used to override compile checks. */
 struct Aligned
-{
-};
+{};
 struct UnAligned
-{
-};
+{};
 
 /** @brief References the data from a buffer if aligned
  *
diff --git a/include/stdplus/str/cat.hpp b/include/stdplus/str/cat.hpp
index 3c39df0..fc97b17 100644
--- a/include/stdplus/str/cat.hpp
+++ b/include/stdplus/str/cat.hpp
@@ -23,8 +23,7 @@
     template <typename... Args>
     constexpr DedSV(Args&&... args) :
         std::basic_string_view<CharT, Traits>(std::forward<Args>(args)...)
-    {
-    }
+    {}
 };
 
 template <typename CharT>
diff --git a/include/stdplus/util/cexec.hpp b/include/stdplus/util/cexec.hpp
index daf402c..a40903e 100644
--- a/include/stdplus/util/cexec.hpp
+++ b/include/stdplus/util/cexec.hpp
@@ -53,7 +53,7 @@
                           "Unimplemented check routine");                      \
         }                                                                      \
         return check_errno_ret;                                                \
-    }((expr))
+        }((expr))
 
 /** @brief   Wraps common c style error handling for exception throwing
  *           This requires the callee to provide error information in -r.
@@ -77,7 +77,7 @@
                           "Unimplemented check routine");                      \
         }                                                                      \
         return check_ret_ret;                                                  \
-    }((expr))
+        }((expr))
 
 namespace stdplus
 {
@@ -156,7 +156,7 @@
  *  @throws std::system_error for an error case.
  *  @return A successful return value based on the function type
  */
-template <auto(*makeError)(int, const char*) = makeSystemError,
+template <auto (*makeError)(int, const char*) = makeSystemError,
           typename... Args>
 inline auto callCheckErrno(const char* msg, Args&&... args)
 {
@@ -181,7 +181,7 @@
         static_assert(std::is_same_v<Ret, int>, "Unimplemented check routine");
     }
 }
-template <auto(*makeError)(int, const char*) = makeSystemError,
+template <auto (*makeError)(int, const char*) = makeSystemError,
           typename... Args>
 inline auto callCheckErrno(const std::string& msg, Args&&... args)
 {
@@ -198,7 +198,7 @@
  *  @throws std::system_error for an error case.
  *  @return A successful return value based on the function type
  */
-template <auto(*makeError)(int, const char*) = makeSystemError,
+template <auto (*makeError)(int, const char*) = makeSystemError,
           typename... Args>
 inline auto callCheckRet(const char* msg, Args&&... args)
 {
@@ -216,7 +216,7 @@
         static_assert(std::is_same_v<Ret, int>, "Unimplemented check routine");
     }
 }
-template <auto(*makeError)(int, const char*) = makeSystemError,
+template <auto (*makeError)(int, const char*) = makeSystemError,
           typename... Args>
 inline auto callCheckRet(const std::string& msg, Args&&... args)
 {
diff --git a/include/stdplus/zstring.hpp b/include/stdplus/zstring.hpp
index 694eeaf..29288ae 100644
--- a/include/stdplus/zstring.hpp
+++ b/include/stdplus/zstring.hpp
@@ -1,6 +1,7 @@
 #pragma once
-#include <cstddef>
 #include <fmt/core.h>
+
+#include <cstddef>
 #include <limits>
 #include <string>
 #include <type_traits>
@@ -50,14 +51,12 @@
 
 template <typename T, typename CharT, typename Traits>
 struct same_string : std::false_type
-{
-};
+{};
 
 template <typename CharT, typename Traits, typename Allocator>
-struct same_string<std::basic_string<CharT, Traits, Allocator>, CharT, Traits>
-    : std::true_type
-{
-};
+struct same_string<std::basic_string<CharT, Traits, Allocator>, CharT, Traits> :
+    std::true_type
+{};
 
 } // namespace detail
 
@@ -97,8 +96,7 @@
     }
     template <typename T, std::enable_if_t<std::is_pointer_v<T>, bool> = true>
     constexpr basic_zstring(T str) noexcept : data_(str)
-    {
-    }
+    {}
     template <typename T,
               std::enable_if_t<detail::same_string<std::remove_cvref_t<T>,
                                                    decay_t, Traits>::value,
@@ -254,8 +252,8 @@
 
 template <typename CharT, typename Traits>
 struct formatter<stdplus::basic_zstring<CharT, Traits>,
-                 std::remove_const_t<CharT>>
-    : formatter<const CharT*, std::remove_const_t<CharT>>
+                 std::remove_const_t<CharT>> :
+    formatter<const CharT*, std::remove_const_t<CharT>>
 {
     template <typename FormatContext>
     inline auto format(stdplus::basic_zstring<CharT, Traits> str,
diff --git a/include/stdplus/zstring_view.hpp b/include/stdplus/zstring_view.hpp
index 3ae13b3..a346130 100644
--- a/include/stdplus/zstring_view.hpp
+++ b/include/stdplus/zstring_view.hpp
@@ -1,7 +1,9 @@
 #pragma once
 #include <fmt/core.h>
-#include <stdexcept>
+
 #include <stdplus/zstring.hpp>
+
+#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <type_traits>
@@ -83,12 +85,10 @@
         :
         sv(str, detail::zstring_validate(str, 0, N))
 #endif
-    {
-    }
+    {}
     template <typename T, std::enable_if_t<std::is_pointer_v<T>, bool> = true>
     constexpr basic_zstring_view(T str) noexcept : sv(str)
-    {
-    }
+    {}
     template <typename T,
               std::enable_if_t<detail::same_string<T, CharT, Traits>::value,
                                bool> = true>
@@ -101,16 +101,14 @@
         sv(str.data(),
            detail::zstring_validate(str.data(), str.size(), str.size() + 1))
 #endif
-    {
-    }
+    {}
     template <
         typename T,
         std::enable_if_t<std::is_same_v<value_type, std::remove_const_t<T>>,
                          bool> = true>
     constexpr basic_zstring_view(basic_zstring<T, Traits> str) noexcept :
         sv(str.data())
-    {
-    }
+    {}
 
     constexpr operator string_view_base() const noexcept
     {
@@ -295,11 +293,9 @@
     string_view_base sv;
 
     struct unsafe
-    {
-    };
+    {};
     constexpr basic_zstring_view(unsafe, string_view_base sv) noexcept : sv(sv)
-    {
-    }
+    {}
     friend auto detail::unsafe_zstring_view<CharT, Traits>(string_view_base sv);
 };
 
@@ -331,10 +327,9 @@
     namespace std                                                              \
     {                                                                          \
     template <>                                                                \
-    struct hash<stdplus::basic_zstring_view<char_t>>                           \
-        : hash<basic_string_view<char_t>>                                      \
-    {                                                                          \
-    };                                                                         \
+    struct hash<stdplus::basic_zstring_view<char_t>> :                         \
+        hash<basic_string_view<char_t>>                                        \
+    {};                                                                        \
     }
 zstring_view_all(char, );
 zstring_view_all(char8_t, u8);
@@ -347,8 +342,8 @@
 {
 
 template <typename CharT, typename Traits>
-struct formatter<stdplus::basic_zstring_view<CharT, Traits>, CharT>
-    : formatter<basic_string_view<CharT>, CharT>
+struct formatter<stdplus::basic_zstring_view<CharT, Traits>, CharT> :
+    formatter<basic_string_view<CharT>, CharT>
 {
     template <typename FormatContext>
     inline auto format(stdplus::basic_zstring_view<CharT, Traits> str,
diff --git a/src/dl.cpp b/src/dl.cpp
index 659389c..050f25c 100644
--- a/src/dl.cpp
+++ b/src/dl.cpp
@@ -8,8 +8,7 @@
 
 Dl::Dl(const char* file, DlOpenFlags flags) :
     handle(open(file, static_cast<int>(flags)))
-{
-}
+{}
 
 struct link_map* Dl::linkMap()
 {
diff --git a/src/exception.cpp b/src/exception.cpp
index c969295..cd79ebc 100644
--- a/src/exception.cpp
+++ b/src/exception.cpp
@@ -24,26 +24,22 @@
 WouldBlock::WouldBlock(const char* what) :
     std::system_error(std::make_error_code(std::errc::operation_would_block),
                       what)
-{
-}
+{}
 
 WouldBlock::WouldBlock(const std::string& what) :
     std::system_error(std::make_error_code(std::errc::operation_would_block),
                       what)
-{
-}
+{}
 
 Eof::Eof(const char* what) :
     std::system_error(std::make_error_code(std::errc::no_message_available),
                       what)
-{
-}
+{}
 
 Eof::Eof(const std::string& what) :
     std::system_error(std::make_error_code(std::errc::no_message_available),
                       what)
-{
-}
+{}
 
 } // namespace exception
 } // namespace stdplus
diff --git a/src/fd/atomic.cpp b/src/fd/atomic.cpp
index df200e6..ce9dff2 100644
--- a/src/fd/atomic.cpp
+++ b/src/fd/atomic.cpp
@@ -1,10 +1,12 @@
-#include <cstdlib>
-#include <filesystem>
 #include <fmt/format.h>
+#include <sys/stat.h>
+
 #include <stdplus/fd/atomic.hpp>
 #include <stdplus/fd/managed.hpp>
 #include <stdplus/util/cexec.hpp>
-#include <sys/stat.h>
+
+#include <cstdlib>
+#include <filesystem>
 #include <system_error>
 #include <utility>
 
@@ -16,8 +18,8 @@
 static std::string makeTmpName(const std::filesystem::path& filename)
 {
     auto name = filename.filename();
-    auto path =
-        filename.parent_path() / fmt::format(".{}.XXXXXX", name.native());
+    auto path = filename.parent_path() /
+                fmt::format(".{}.XXXXXX", name.native());
     return path.native();
 }
 
@@ -38,8 +40,7 @@
     mode(mode),
     tmpname(!tmpl.empty() ? std::string(tmpl) : makeTmpName(filename)),
     fd(mktemp(tmpname))
-{
-}
+{}
 
 AtomicWriter::AtomicWriter(AtomicWriter&& other) :
     filename(std::move(other.filename)), mode(other.mode),
diff --git a/src/fd/create.cpp b/src/fd/create.cpp
index 2240a98..bfef66f 100644
--- a/src/fd/create.cpp
+++ b/src/fd/create.cpp
@@ -1,8 +1,9 @@
 #include <fcntl.h>
 #include <fmt/format.h>
+#include <sys/socket.h>
+
 #include <stdplus/fd/create.hpp>
 #include <stdplus/util/cexec.hpp>
-#include <sys/socket.h>
 
 namespace stdplus
 {
diff --git a/src/fd/dupable.cpp b/src/fd/dupable.cpp
index ce2cff1..d096d04 100644
--- a/src/fd/dupable.cpp
+++ b/src/fd/dupable.cpp
@@ -1,7 +1,9 @@
 #include <fcntl.h>
+
 #include <stdplus/fd/dupable.hpp>
 #include <stdplus/fd/ops.hpp>
 #include <stdplus/util/cexec.hpp>
+
 #include <utility>
 
 namespace stdplus
@@ -18,13 +20,9 @@
 
 } // namespace detail
 
-DupableFd::DupableFd() noexcept : handle(std::nullopt)
-{
-}
+DupableFd::DupableFd() noexcept : handle(std::nullopt) {}
 
-DupableFd::DupableFd(const int& fd) : handle(fd)
-{
-}
+DupableFd::DupableFd(const int& fd) : handle(fd) {}
 
 DupableFd::DupableFd(int&& fd) : handle(std::move(fd))
 {
diff --git a/src/fd/fmt.cpp b/src/fd/fmt.cpp
index 94d3bc1..1907ded 100644
--- a/src/fd/fmt.cpp
+++ b/src/fd/fmt.cpp
@@ -6,9 +6,7 @@
 namespace fd
 {
 
-FormatBuffer::FormatBuffer(Fd& fd, size_t max) : fd(fd), max(max)
-{
-}
+FormatBuffer::FormatBuffer(Fd& fd, size_t max) : fd(fd), max(max) {}
 
 FormatBuffer::~FormatBuffer() noexcept(false)
 {
diff --git a/src/fd/impl.cpp b/src/fd/impl.cpp
index 34b365f..1272fc8 100644
--- a/src/fd/impl.cpp
+++ b/src/fd/impl.cpp
@@ -1,13 +1,15 @@
 #include <fcntl.h>
 #include <fmt/format.h>
-#include <stdplus/exception.hpp>
-#include <stdplus/fd/impl.hpp>
-#include <stdplus/util/cexec.hpp>
-#include <string_view>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
+#include <stdplus/exception.hpp>
+#include <stdplus/fd/impl.hpp>
+#include <stdplus/util/cexec.hpp>
+
+#include <string_view>
+
 namespace stdplus
 {
 namespace fd
@@ -35,8 +37,8 @@
 
 std::span<std::byte> FdImpl::recv(std::span<std::byte> buf, RecvFlags flags)
 {
-    ssize_t amt =
-        ::recv(get(), buf.data(), buf.size(), static_cast<int>(flags));
+    ssize_t amt = ::recv(get(), buf.data(), buf.size(),
+                         static_cast<int>(flags));
     if (amt == -1)
     {
         if (errno == EAGAIN || errno == EWOULDBLOCK)
@@ -69,8 +71,8 @@
 std::span<const std::byte> FdImpl::send(std::span<const std::byte> data,
                                         SendFlags flags)
 {
-    ssize_t amt =
-        ::send(get(), data.data(), data.size(), static_cast<int>(flags));
+    ssize_t amt = ::send(get(), data.data(), data.size(),
+                         static_cast<int>(flags));
     if (amt == -1)
     {
         if (errno == EAGAIN || errno == EWOULDBLOCK)
diff --git a/src/fd/line.cpp b/src/fd/line.cpp
index db12041..b3ce76a 100644
--- a/src/fd/line.cpp
+++ b/src/fd/line.cpp
@@ -1,16 +1,15 @@
-#include <cstring>
 #include <stdplus/exception.hpp>
 #include <stdplus/fd/line.hpp>
 #include <stdplus/fd/ops.hpp>
 
+#include <cstring>
+
 namespace stdplus
 {
 namespace fd
 {
 
-LineReader::LineReader(Fd& fd) : fd(fd)
-{
-}
+LineReader::LineReader(Fd& fd) : fd(fd) {}
 
 const std::string* LineReader::readLine()
 {
diff --git a/src/fd/managed.cpp b/src/fd/managed.cpp
index 1b19284..cd4ec1c 100644
--- a/src/fd/managed.cpp
+++ b/src/fd/managed.cpp
@@ -1,9 +1,11 @@
 #include <fmt/format.h>
+#include <unistd.h>
+
 #include <stdplus/fd/dupable.hpp>
 #include <stdplus/fd/managed.hpp>
 #include <stdplus/fd/ops.hpp>
 #include <stdplus/util/cexec.hpp>
-#include <unistd.h>
+
 #include <utility>
 
 namespace stdplus
@@ -20,9 +22,7 @@
 
 } // namespace detail
 
-ManagedFd::ManagedFd() noexcept : handle(std::nullopt)
-{
-}
+ManagedFd::ManagedFd() noexcept : handle(std::nullopt) {}
 
 ManagedFd::ManagedFd(int&& fd) : handle(std::move(fd))
 {
@@ -31,12 +31,9 @@
 
 ManagedFd::ManagedFd(DupableFd&& other) noexcept :
     handle(static_cast<detail::ManagedFdHandle&&>(other.handle))
-{
-}
+{}
 
-ManagedFd::ManagedFd(const DupableFd& other) : ManagedFd(DupableFd(other))
-{
-}
+ManagedFd::ManagedFd(const DupableFd& other) : ManagedFd(DupableFd(other)) {}
 
 ManagedFd& ManagedFd::operator=(DupableFd&& other) noexcept
 {
diff --git a/src/fd/mmap.cpp b/src/fd/mmap.cpp
index 079815d..1f5c211 100644
--- a/src/fd/mmap.cpp
+++ b/src/fd/mmap.cpp
@@ -9,8 +9,7 @@
 MMap::MMap(Fd& fd, std::span<std::byte> window, ProtFlags prot, MMapFlags flags,
            off_t offset) :
     mapping(fd.mmap(window, prot, flags, offset), fd)
-{
-}
+{}
 
 std::span<std::byte> MMap::get() const
 {
diff --git a/src/fd/ops.cpp b/src/fd/ops.cpp
index d47dbb3..e8f3636 100644
--- a/src/fd/ops.cpp
+++ b/src/fd/ops.cpp
@@ -1,6 +1,8 @@
 #include <fmt/format.h>
+
 #include <stdplus/exception.hpp>
 #include <stdplus/fd/ops.hpp>
+
 #include <utility>
 
 namespace stdplus
@@ -54,8 +56,8 @@
     std::span<Byte> ret;
     do
     {
-        auto r =
-            (fd.*fun)(data.subspan(ret.size()), std::forward<Args>(args)...);
+        auto r = (fd.*fun)(data.subspan(ret.size()),
+                           std::forward<Args>(args)...);
         if (ret.size() != 0 && r.size() == 0)
         {
             throw exception::WouldBlock(
diff --git a/src/gtest/tmp.cpp b/src/gtest/tmp.cpp
index 07dfb6d..4d06de5 100644
--- a/src/gtest/tmp.cpp
+++ b/src/gtest/tmp.cpp
@@ -1,8 +1,9 @@
 #include <fmt/format.h>
 
-#include <filesystem>
 #include <stdplus/gtest/tmp.hpp>
 
+#include <filesystem>
+
 namespace stdplus
 {
 namespace gtest
diff --git a/src/io_uring.cpp b/src/io_uring.cpp
index 0dec400..0e6a7b4 100644
--- a/src/io_uring.cpp
+++ b/src/io_uring.cpp
@@ -1,5 +1,4 @@
 #include <liburing.h>
-
 #include <sys/eventfd.h>
 
 #include <stdplus/fd/managed.hpp>
@@ -45,8 +44,7 @@
 
 IoUring::FileHandle::FileHandle(unsigned slot, IoUring& ring) :
     slot(slot, &ring)
-{
-}
+{}
 
 void IoUring::FileHandle::drop(unsigned&& slot, IoUring*& ring)
 {
diff --git a/src/signal.cpp b/src/signal.cpp
index 525f2c0..3acba26 100644
--- a/src/signal.cpp
+++ b/src/signal.cpp
@@ -1,6 +1,8 @@
 #include <signal.h>
+
 #include <stdplus/signal.hpp>
 #include <stdplus/util/cexec.hpp>
+
 #include <system_error>
 
 namespace stdplus
diff --git a/test/cancel.cpp b/test/cancel.cpp
index 3efefb8..f1f9588 100644
--- a/test/cancel.cpp
+++ b/test/cancel.cpp
@@ -1,6 +1,7 @@
-#include <functional>
 #include <stdplus/cancel.hpp>
 
+#include <functional>
+
 #include <gtest/gtest.h>
 
 namespace stdplus
diff --git a/test/dl.cpp b/test/dl.cpp
index cc16293..8ded85d 100644
--- a/test/dl.cpp
+++ b/test/dl.cpp
@@ -1,6 +1,7 @@
-#include <gtest/gtest.h>
 #include <stdplus/dl.hpp>
 
+#include <gtest/gtest.h>
+
 namespace stdplus
 {
 
diff --git a/test/exception.cpp b/test/exception.cpp
index 5d22071..a0d2e54 100644
--- a/test/exception.cpp
+++ b/test/exception.cpp
@@ -1,6 +1,7 @@
-#include <gtest/gtest.h>
 #include <stdplus/exception.hpp>
 
+#include <gtest/gtest.h>
+
 namespace stdplus
 {
 namespace exception
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);
diff --git a/test/fd/dupable.cpp b/test/fd/dupable.cpp
index e203932..3431e54 100644
--- a/test/fd/dupable.cpp
+++ b/test/fd/dupable.cpp
@@ -1,4 +1,2 @@
 #include <stdplus/fd/dupable.hpp>
-int main(int, char*[])
-{
-}
+int main(int, char*[]) {}
diff --git a/test/fd/fmt.cpp b/test/fd/fmt.cpp
index f7ff9d8..770bc99 100644
--- a/test/fd/fmt.cpp
+++ b/test/fd/fmt.cpp
@@ -1,14 +1,15 @@
-#include <gtest/gtest.h>
-
 #include <fmt/compile.h>
+#include <sys/mman.h>
+
 #include <stdplus/fd/fmt.hpp>
 #include <stdplus/fd/managed.hpp>
 #include <stdplus/util/cexec.hpp>
-#include <sys/mman.h>
 
 #include <string>
 #include <string_view>
 
+#include <gtest/gtest.h>
+
 namespace stdplus
 {
 namespace fd
diff --git a/test/fd/impl.cpp b/test/fd/impl.cpp
index 6d0c00b..7806b45 100644
--- a/test/fd/impl.cpp
+++ b/test/fd/impl.cpp
@@ -1,4 +1,2 @@
 #include <stdplus/fd/impl.hpp>
-int main(int, char*[])
-{
-}
+int main(int, char*[]) {}
diff --git a/test/fd/intf.cpp b/test/fd/intf.cpp
index d4cc8c2..bc58756 100644
--- a/test/fd/intf.cpp
+++ b/test/fd/intf.cpp
@@ -1,4 +1,2 @@
 #include <stdplus/fd/intf.hpp>
-int main(int, char*[])
-{
-}
+int main(int, char*[]) {}
diff --git a/test/fd/line.cpp b/test/fd/line.cpp
index 8d9eb32..2913a25 100644
--- a/test/fd/line.cpp
+++ b/test/fd/line.cpp
@@ -1,4 +1,5 @@
-#include <gtest/gtest.h>
+#include <sys/mman.h>
+
 #include <stdplus/exception.hpp>
 #include <stdplus/fd/gmock.hpp>
 #include <stdplus/fd/line.hpp>
@@ -6,8 +7,10 @@
 #include <stdplus/fd/ops.hpp>
 #include <stdplus/raw.hpp>
 #include <stdplus/util/cexec.hpp>
+
 #include <string_view>
-#include <sys/mman.h>
+
+#include <gtest/gtest.h>
 
 namespace stdplus
 {
@@ -70,7 +73,10 @@
 inline auto readSv(std::string_view s)
 {
     return [s](std::span<std::byte> buf) {
-        memcpy(buf.data(), s.data(), s.size());
+        if (s.size())
+        {
+            memcpy(buf.data(), s.data(), s.size());
+        }
         return buf.subspan(0, s.size());
     };
 }
diff --git a/test/fd/managed.cpp b/test/fd/managed.cpp
index f365618..a232fdc 100644
--- a/test/fd/managed.cpp
+++ b/test/fd/managed.cpp
@@ -1,4 +1,2 @@
 #include <stdplus/fd/managed.hpp>
-int main(int, char*[])
-{
-}
+int main(int, char*[]) {}
diff --git a/test/fd/mmap.cpp b/test/fd/mmap.cpp
index 3f1ab33..bf73556 100644
--- a/test/fd/mmap.cpp
+++ b/test/fd/mmap.cpp
@@ -1,8 +1,10 @@
-#include <array>
-#include <gtest/gtest.h>
 #include <stdplus/fd/create.hpp>
 #include <stdplus/fd/mmap.hpp>
 
+#include <array>
+
+#include <gtest/gtest.h>
+
 namespace stdplus
 {
 namespace fd
diff --git a/test/fd/mock.cpp b/test/fd/mock.cpp
index 0cc6dfd..a3ad784 100644
--- a/test/fd/mock.cpp
+++ b/test/fd/mock.cpp
@@ -1,6 +1,7 @@
-#include <gtest/gtest.h>
 #include <stdplus/fd/gmock.hpp>
 
+#include <gtest/gtest.h>
+
 namespace stdplus
 {
 
diff --git a/test/fd/ops.cpp b/test/fd/ops.cpp
index 2d52101..c0328fe 100644
--- a/test/fd/ops.cpp
+++ b/test/fd/ops.cpp
@@ -1,6 +1,7 @@
-#include <gtest/gtest.h>
 #include <stdplus/fd/ops.hpp>
 
+#include <gtest/gtest.h>
+
 namespace stdplus
 {
 namespace fd
diff --git a/test/gtest/tmp.cpp b/test/gtest/tmp.cpp
index f473175..c1b7c74 100644
--- a/test/gtest/tmp.cpp
+++ b/test/gtest/tmp.cpp
@@ -1,15 +1,16 @@
-#include <filesystem>
-#include <gtest/gtest.h>
 #include <stdplus/gtest/tmp.hpp>
 
+#include <filesystem>
+
+#include <gtest/gtest.h>
+
 namespace stdplus
 {
 namespace gtest
 {
 
 class TestWithTmpTest : public TestWithTmp
-{
-};
+{};
 
 TEST_F(TestWithTmpTest, One)
 {
@@ -28,8 +29,7 @@
 }
 
 class TestWithTmpTest2 : public TestWithTmp
-{
-};
+{};
 
 TEST_F(TestWithTmpTest2, One)
 {
diff --git a/test/handle/copyable.cpp b/test/handle/copyable.cpp
index cd17c54..161b808 100644
--- a/test/handle/copyable.cpp
+++ b/test/handle/copyable.cpp
@@ -1,10 +1,12 @@
-#include <gtest/gtest.h>
-#include <optional>
 #include <stdplus/handle/copyable.hpp>
+
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include <gtest/gtest.h>
+
 namespace stdplus
 {
 namespace
diff --git a/test/handle/managed.cpp b/test/handle/managed.cpp
index fb89195..74816e5 100644
--- a/test/handle/managed.cpp
+++ b/test/handle/managed.cpp
@@ -1,11 +1,13 @@
-#include <gtest/gtest.h>
-#include <optional>
 #include <stdplus/handle/managed.hpp>
+
+#include <optional>
 #include <string>
 #include <tuple>
 #include <utility>
 #include <vector>
 
+#include <gtest/gtest.h>
+
 namespace stdplus
 {
 namespace
diff --git a/test/io_uring.cpp b/test/io_uring.cpp
index 8a9f2c0..7a646e2 100644
--- a/test/io_uring.cpp
+++ b/test/io_uring.cpp
@@ -1,14 +1,15 @@
+#include <fmt/format.h>
 #include <poll.h>
+#include <sys/utsname.h>
+
+#include <stdplus/io_uring.hpp>
+#include <stdplus/util/cexec.hpp>
 
 #include <array>
 #include <charconv>
 #include <chrono>
-#include <fmt/format.h>
 #include <optional>
-#include <stdplus/io_uring.hpp>
-#include <stdplus/util/cexec.hpp>
 #include <string_view>
-#include <sys/utsname.h>
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
diff --git a/test/pinned.cpp b/test/pinned.cpp
index f33f41a..5e58dc4 100644
--- a/test/pinned.cpp
+++ b/test/pinned.cpp
@@ -1,7 +1,9 @@
-#include <gtest/gtest.h>
 #include <stdplus/pinned.hpp>
+
 #include <string>
 
+#include <gtest/gtest.h>
+
 namespace stdplus
 {
 
diff --git a/test/raw.cpp b/test/raw.cpp
index 0de4c33..fa3c77e 100644
--- a/test/raw.cpp
+++ b/test/raw.cpp
@@ -1,13 +1,16 @@
-#include <array>
 #include <endian.h>
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
+
+#include <stdplus/raw.hpp>
+
+#include <array>
 #include <span>
 #include <stdexcept>
-#include <stdplus/raw.hpp>
 #include <string_view>
 #include <vector>
 
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
 namespace stdplus
 {
 namespace raw
diff --git a/test/signal.cpp b/test/signal.cpp
index d060861..3ca2695 100644
--- a/test/signal.cpp
+++ b/test/signal.cpp
@@ -1,8 +1,11 @@
-#include <cstring>
-#include <gtest/gtest.h>
 #include <signal.h>
+
 #include <stdplus/signal.hpp>
 
+#include <cstring>
+
+#include <gtest/gtest.h>
+
 namespace stdplus
 {
 namespace signal
diff --git a/test/str/cat.cpp b/test/str/cat.cpp
index 1633f6e..758facc 100644
--- a/test/str/cat.cpp
+++ b/test/str/cat.cpp
@@ -1,8 +1,10 @@
-#include <gtest/gtest.h>
 #include <stdplus/str/cat.hpp>
+
 #include <string>
 #include <string_view>
 
+#include <gtest/gtest.h>
+
 namespace stdplus
 {
 
diff --git a/test/util/cexec.cpp b/test/util/cexec.cpp
index f5b7a5e..3c2099e 100644
--- a/test/util/cexec.cpp
+++ b/test/util/cexec.cpp
@@ -1,8 +1,10 @@
-#include <gtest/gtest.h>
 #include <stdplus/util/cexec.hpp>
+
 #include <string_view>
 #include <system_error>
 
+#include <gtest/gtest.h>
+
 namespace stdplus
 {
 namespace util
diff --git a/test/zstring.cpp b/test/zstring.cpp
index 69b3c9f..53c3a14 100644
--- a/test/zstring.cpp
+++ b/test/zstring.cpp
@@ -1,10 +1,13 @@
 #include <fmt/format.h>
-#include <gtest/gtest.h>
-#include <iostream>
+
 #include <stdplus/zstring.hpp>
+
+#include <iostream>
 #include <string>
 #include <string_view>
 
+#include <gtest/gtest.h>
+
 using std::literals::string_literals::operator""s;
 using std::literals::string_view_literals::operator""sv;
 
diff --git a/test/zstring_view.cpp b/test/zstring_view.cpp
index 40ad4d4..8b29bc9 100644
--- a/test/zstring_view.cpp
+++ b/test/zstring_view.cpp
@@ -1,11 +1,14 @@
 #include <fmt/format.h>
-#include <gtest/gtest.h>
+
+#include <stdplus/zstring_view.hpp>
+
 #include <iostream>
 #include <set>
-#include <stdplus/zstring_view.hpp>
 #include <string>
 #include <unordered_set>
 
+#include <gtest/gtest.h>
+
 namespace stdplus
 {