Add .clang-format

Make it easier to keep a consistent style

34 files changed, 903 insertions, 587 deletions

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..aa4a4dc
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,315 @@
+---
+Language:        Cpp
+AccessModifierOffset: -1
+AlignAfterOpenBracket: Align
+AlignArrayOfStructures: None
+AlignConsecutiveAssignments:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    true
+AlignConsecutiveBitFields:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveDeclarations:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: true
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveMacros:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveShortCaseStatements:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCaseArrows: false
+  AlignCaseColons: false
+AlignConsecutiveTableGenBreakingDAGArgColons:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveTableGenCondOperatorColons:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveTableGenDefinitionColons:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignEscapedNewlines: Left
+AlignOperands:   Align
+AlignTrailingComments:
+  Kind:            Always
+  OverEmptyLines:  0
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowBreakBeforeNoexceptSpecifier: Never
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseExpressionOnASingleLine: true
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortCompoundRequirementOnASingleLine: true
+AllowShortEnumsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLambdasOnASingleLine: All
+AllowShortLoopsOnASingleLine: false
+AllowShortNamespacesOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AttributeMacros:
+  - __capability
+BinPackArguments: true
+BinPackParameters: BinPack
+BitFieldColonSpacing: Both
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: Never
+  AfterEnum:       false
+  AfterExternBlock: false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  BeforeCatch:     false
+  BeforeElse:      false
+  BeforeLambdaBody: false
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BracedInitializerIndentWidth: 2
+BreakAdjacentStringLiterals: true
+BreakAfterAttributes: Leave
+BreakAfterJavaFieldAnnotations: false
+BreakAfterReturnType: None
+BreakArrays:     true
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: Always
+BreakBeforeBraces: Attach
+BreakBeforeInlineASMColon: OnlyMultiline
+BreakBeforeTernaryOperators: true
+BreakBinaryOperations: Never
+BreakConstructorInitializers: BeforeColon
+BreakFunctionDefinitionParameters: false
+BreakInheritanceList: BeforeColon
+BreakStringLiterals: true
+BreakTemplateDeclarations: Yes
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: true
+DisableFormat:   false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: LogicalBlock
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IfMacros:
+  - KJ_IF_MAYBE
+IncludeBlocks:   Regroup
+IncludeCategories:
+  - Regex:           '^<.*'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '.*'
+    Priority:        1
+    SortPriority:    0
+    CaseSensitive:   false
+IncludeIsMainRegex: '([-_](lzma|z|test|unittest))?$'
+IncludeIsMainSourceRegex: ''
+IndentAccessModifiers: false
+IndentCaseBlocks: false
+IndentCaseLabels: true
+IndentExportBlock: true
+IndentExternBlock: AfterExternBlock
+IndentGotoLabels: true
+IndentPPDirectives: AfterHash
+IndentRequiresClause: true
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+InsertBraces:    false
+InsertNewlineAtEOF: false
+InsertTrailingCommas: None
+IntegerLiteralSeparator:
+  Binary:          0
+  BinaryMinDigits: 0
+  Decimal:         0
+  DecimalMinDigits: 0
+  Hex:             0
+  HexMinDigits:    0
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLines:
+  AtEndOfFile:     false
+  AtStartOfBlock:  false
+  AtStartOfFile:   true
+KeepFormFeed:    false
+LambdaBodyIndentation: Signature
+LineEnding:      DeriveLF
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MainIncludeChar: Quote
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Never
+ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PackConstructorInitializers: NextLine
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakBeforeMemberAccess: 150
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakOpenParenthesis: 0
+PenaltyBreakScopeResolution: 500
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyIndentedWhitespace: 0
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Left
+PPIndentWidth: 1
+QualifierAlignment: Leave
+RawStringFormats:
+  - Language:        Cpp
+    Delimiters:
+      - cc
+      - CC
+      - cpp
+      - Cpp
+      - CPP
+      - 'c++'
+      - 'C++'
+    CanonicalDelimiter: ''
+    BasedOnStyle:    google
+  - Language:        TextProto
+    Delimiters:
+      - pb
+      - PB
+      - proto
+      - PROTO
+    EnclosingFunctions:
+      - EqualsProto
+      - EquivToProto
+      - PARSE_PARTIAL_TEXT_PROTO
+      - PARSE_TEST_PROTO
+      - PARSE_TEXT_PROTO
+      - ParseTextOrDie
+      - ParseTextProtoOrDie
+      - ParseTestProto
+      - ParsePartialTestProto
+    CanonicalDelimiter: pb
+    BasedOnStyle:    google
+ReferenceAlignment: Pointer
+ReflowComments: IndentOnly
+RemoveBracesLLVM: false
+RemoveEmptyLinesInUnwrappedLines: false
+RemoveParentheses: Leave
+RemoveSemicolon: false
+RequiresClausePosition: OwnLine
+RequiresExpressionIndentation: OuterScope
+SeparateDefinitionBlocks: Leave
+ShortNamespaceLines: 1
+SkipMacroDefinitionBody: false
+SortIncludes:    CaseSensitive
+SortJavaStaticImport: Before
+SortUsingDeclarations: LexicographicNumeric
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeJsonColon: false
+SpaceBeforeParens: ControlStatements
+SpaceBeforeParensOptions:
+  AfterControlStatements: true
+  AfterForeachMacros: true
+  AfterFunctionDefinitionName: false
+  AfterFunctionDeclarationName: false
+  AfterIfMacros:   true
+  AfterOverloadedOperator: false
+  AfterPlacementOperator: true
+  AfterRequiresInClause: false
+  AfterRequiresInExpression: false
+  BeforeNonEmptyParentheses: false
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceBeforeSquareBrackets: false
+SpaceInEmptyBlock: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles:  Never
+SpacesInContainerLiterals: true
+SpacesInLineCommentPrefix:
+  Minimum:         1
+  Maximum:         -1
+SpacesInParens:  Never
+SpacesInParensOptions:
+  ExceptDoubleParentheses: false
+  InCStyleCasts:   false
+  InConditionalStatements: false
+  InEmptyParentheses: false
+  Other:           false
+SpacesInSquareBrackets: false
+Standard:        Auto
+StatementAttributeLikeMacros:
+  - Q_EMIT
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TableGenBreakInsideDAGArg: DontBreak
+TabWidth:        8
+UseTab:          Never
+VerilogBreakBetweenInstancePorts: true
+WhitespaceSensitiveMacros:
+  - BOOST_PP_STRINGIZE
+  - CF_SWIFT_NAME
+  - NS_SWIFT_NAME
+  - PP_STRINGIZE
+  - STRINGIZE
+WrapNamespaceBodyWithEmptyLines: Leave
+...
+
diff --git a/src/args.cc b/src/args.cc
index 078db1a..1794941 100644
--- a/src/args.cc
+++ b/src/args.cc
@@ -26,10 +26,13 @@ class OptionImpl : public Args::OptionArgument {
     OptionalArgument,
   };
 
-  OptionImpl(Type type, char shortname, std::string longname,
-             std::string arg, std::string help)
-      : type(type), shortname(shortname), longname(std::move(longname)),
-        arg(std::move(arg)), help(std::move(help)) {}
+  OptionImpl(Type type, char shortname, std::string longname, std::string arg,
+             std::string help)
+      : type(type),
+        shortname(shortname),
+        longname(std::move(longname)),
+        arg(std::move(arg)),
+        help(std::move(help)) {}
 
   const Type type;
   const char shortname;
@@ -57,13 +60,13 @@ class OptionImpl : public Args::OptionArgument {
 
   void set_argument(std::string value) {
     assert(type == Type::RequiredArgument || type == Type::OptionalArgument);
-    is_set_= true;
+    is_set_ = true;
     value_ = std::move(value);
   }
 
   void set_no_argument() {
     assert(type == Type::NoArgument || type == Type::OptionalArgument);
-    is_set_= true;
+    is_set_ = true;
     value_.reset();
   }
 
@@ -74,11 +77,10 @@ class OptionImpl : public Args::OptionArgument {
 
 class ArgsImpl : public Args {
  public:
-  explicit ArgsImpl(std::string prgname)
-      : prgname_(std::move(prgname)) {}
+  explicit ArgsImpl(std::string prgname) : prgname_(std::move(prgname)) {}
 
-  std::shared_ptr<Option> option(
-      char shortname, std::string longname, std::string help) override {
+  std::shared_ptr<Option> option(char shortname, std::string longname,
+                                 std::string help) override {
     auto opt = std::make_shared<OptionImpl>(
         OptionImpl::Type::NoArgument, shortname, std::move(longname),
         /* arg */ std::string(), std::move(help));
@@ -86,13 +88,15 @@ class ArgsImpl : public Args {
     return opt;
   }
 
-  std::shared_ptr<OptionArgument> option_argument(
-      char shortname, std::string longname, std::string arg,
-      std::string help, bool required) override {
+  std::shared_ptr<OptionArgument> option_argument(char shortname,
+                                                  std::string longname,
+                                                  std::string arg,
+                                                  std::string help,
+                                                  bool required) override {
     auto opt = std::make_shared<OptionImpl>(
-        required ? OptionImpl::Type::RequiredArgument :
-        OptionImpl::Type::OptionalArgument, shortname, std::move(longname),
-        std::move(arg), std::move(help));
+        required ? OptionImpl::Type::RequiredArgument
+                 : OptionImpl::Type::OptionalArgument,
+        shortname, std::move(longname), std::move(arg), std::move(help));
     add(opt);
     return opt;
   }
@@ -118,9 +122,11 @@ class ArgsImpl : public Args {
         if (argv[a][1] == '-') {
           // long option
           size_t eq = 2;
-          while (argv[a][eq] != '=' && argv[a][eq] != '\0') ++eq;
+          while (argv[a][eq] != '=' && argv[a][eq] != '\0')
+            ++eq;
           size_t end = eq;
-          while (argv[a][end] != '\0') ++end;
+          while (argv[a][end] != '\0')
+            ++end;
 
           if (end == 2) {
             // "--", no more options signal
@@ -134,8 +140,8 @@ class ArgsImpl : public Args {
           auto name = std::string_view(argv[a] + 2, eq - 2);
           auto it = long_.find(name);
           if (it == long_.end()) {
-            last_error_ = std::format("{}: unrecognized option '--{}'",
-                                      prgname, name);
+            last_error_ =
+                std::format("{}: unrecognized option '--{}'", prgname, name);
             return false;
           }
           auto& opt = options_[it->second];
@@ -144,9 +150,9 @@ class ArgsImpl : public Args {
             // long option with argument after equal sign
             switch (opt->type) {
               case OptionImpl::Type::NoArgument:
-                last_error_ = std::format(
-                    "{}: option '--{}' doesn't allow an argument",
-                    prgname, name);
+                last_error_ =
+                    std::format("{}: option '--{}' doesn't allow an argument",
+                                prgname, name);
                 return false;
               case OptionImpl::Type::RequiredArgument:
               case OptionImpl::Type::OptionalArgument:
@@ -163,8 +169,7 @@ class ArgsImpl : public Args {
               case OptionImpl::Type::RequiredArgument:
                 if (++a >= argc) {
                   last_error_ = std::format(
-                      "{}: option '--{}' requires an argument",
-                      prgname, name);
+                      "{}: option '--{}' requires an argument", prgname, name);
                   return false;
                 }
                 opt->set_argument(argv[a]);
@@ -177,8 +182,8 @@ class ArgsImpl : public Args {
           for (; *current; ++current) {
             auto it = short_.find(*current);
             if (it == short_.end()) {
-              last_error_ = std::format("{}: invalid option -- '{}'",
-                                        prgname, *current);
+              last_error_ =
+                  std::format("{}: invalid option -- '{}'", prgname, *current);
               return false;
             }
 
@@ -190,9 +195,9 @@ class ArgsImpl : public Args {
                 break;
               case OptionImpl::Type::RequiredArgument:
                 if (++a >= argc) {
-                  last_error_ = std::format(
-                      "{}: option requires an argument -- '{}'",
-                      prgname, *current);
+                  last_error_ =
+                      std::format("{}: option requires an argument -- '{}'",
+                                  prgname, *current);
                   return false;
                 }
                 opt->set_argument(argv[a]);
@@ -209,13 +214,15 @@ class ArgsImpl : public Args {
   }
 
   void print_error(std::ostream& out) const override {
-    if (last_error_.empty()) return;
+    if (last_error_.empty())
+      return;
 
     out << last_error_ << '\n';
   }
 
   void print_help(std::ostream& out, uint32_t width = 79) const override {
-    if (options_.empty()) return;
+    if (options_.empty())
+      return;
 
     uint32_t indent = 0;
     const uint32_t max_need = width / 2;
@@ -223,7 +230,7 @@ class ArgsImpl : public Args {
     for (auto const& opt : options_) {
       uint32_t need;
       if (opt->longname.empty()) {
-        need = 4; // -O
+        need = 4;  // -O
         switch (opt->type) {
           case OptionImpl::Type::NoArgument:
           case OptionImpl::Type::OptionalArgument:
@@ -233,7 +240,7 @@ class ArgsImpl : public Args {
             break;
         }
       } else {
-        need = 8 + opt->longname.size(); // -O, --option
+        need = 8 + opt->longname.size();  // -O, --option
         switch (opt->type) {
           case OptionImpl::Type::NoArgument:
             break;
@@ -247,7 +254,7 @@ class ArgsImpl : public Args {
             break;
         }
       }
-      need += 2; // margin
+      need += 2;  // margin
 
       option_need.emplace_back(need);
       if (need <= max_need) {
@@ -255,7 +262,8 @@ class ArgsImpl : public Args {
       }
     }
 
-    print_wrap(out, width, /* indent */ 0, "Mandatory arguments to long options"
+    print_wrap(out, width, /* indent */ 0,
+               "Mandatory arguments to long options"
                " are mandatory for short options too.");
     auto need_it = option_need.begin();
     for (auto const& opt : options_) {
@@ -321,12 +329,10 @@ class ArgsImpl : public Args {
     options_.emplace_back(std::move(opt));
   }
 
-  static inline bool is_whitespace(char c) {
-    return c == ' ' || c == '\t';
-  }
+  static inline bool is_whitespace(char c) { return c == ' ' || c == '\t'; }
 
   static void print_wrap(std::ostream& out, uint32_t width, uint32_t indent,
-                  const std::string& str) {
+                         const std::string& str) {
     if (indent + str.size() <= width) {
       out << str << '\n';
       return;
@@ -341,7 +347,8 @@ class ArgsImpl : public Args {
     size_t offset = 0;
     while (offset + avail < str.size()) {
       uint32_t i = avail;
-      while (i > 0 && !is_whitespace(str[offset + i])) --i;
+      while (i > 0 && !is_whitespace(str[offset + i]))
+        --i;
       if (i == 0) {
         out << str.substr(offset, avail - 1);
         out << "-\n";
@@ -366,8 +373,8 @@ class ArgsImpl : public Args {
 
 }  // namespace
 
-std::shared_ptr<Args::Option> Args::option(
-    std::string longname, std::string help) {
+std::shared_ptr<Args::Option> Args::option(std::string longname,
+                                           std::string help) {
   return option(/* shortname */ '\0', std::move(longname), std::move(help));
 }
 
diff --git a/src/args.hh b/src/args.hh
index 2436696..14f3716 100644
--- a/src/args.hh
+++ b/src/args.hh
@@ -32,27 +32,21 @@ class Args {
 
   static std::unique_ptr<Args> create(std::string prgname = std::string());
 
-  virtual std::shared_ptr<Option> option(
-      char shortname,
-      std::string longname = std::string(),
-      std::string help = std::string()) = 0;
+  virtual std::shared_ptr<Option> option(char shortname,
+                                         std::string longname = std::string(),
+                                         std::string help = std::string()) = 0;
 
-  std::shared_ptr<Option> option(
-      std::string longname,
-      std::string help = std::string());
+  std::shared_ptr<Option> option(std::string longname,
+                                 std::string help = std::string());
 
   virtual std::shared_ptr<OptionArgument> option_argument(
-      char shortname,
-      std::string longname = std::string(),
-      std::string arg = std::string(),
-      std::string help = std::string(),
+      char shortname, std::string longname = std::string(),
+      std::string arg = std::string(), std::string help = std::string(),
       bool required = true) = 0;
 
   std::shared_ptr<OptionArgument> option_argument(
-      std::string longname,
-      std::string arg = std::string(),
-      std::string help = std::string(),
-      bool required = true);
+      std::string longname, std::string arg = std::string(),
+      std::string help = std::string(), bool required = true);
 
   virtual bool run(int argc, char** argv,
                    std::vector<std::string_view>* arguments = nullptr) = 0;
diff --git a/src/buffer.cc b/src/buffer.cc
index 3073a45..18913a5 100644
--- a/src/buffer.cc
+++ b/src/buffer.cc
@@ -10,8 +10,7 @@ namespace {
 
 class FixedBuffer : public Buffer {
  public:
-  explicit FixedBuffer(size_t size)
-      : size_(size) {}
+  explicit FixedBuffer(size_t size) : size_(size) {}
 
   void const* rptr(size_t& avail, size_t need) override {
     if (rptr_ < wptr_) {
@@ -29,7 +28,8 @@ class FixedBuffer : public Buffer {
   }
 
   void consume(size_t size) override {
-    if (size == 0) return;
+    if (size == 0)
+      return;
     if (rptr_ < wptr_) {
       assert(std::cmp_greater_equal(wptr_ - rptr_, size));
       rptr_ += size;
@@ -68,7 +68,8 @@ class FixedBuffer : public Buffer {
   }
 
   void commit(size_t size) override {
-    if (size == 0) return;
+    if (size == 0)
+      return;
     if (wptr_ < rptr_) {
       assert(std::cmp_greater_equal(rptr_ - wptr_, size));
       wptr_ += size;
@@ -87,13 +88,9 @@ class FixedBuffer : public Buffer {
     }
   }
 
-  [[nodiscard]] bool full() const override {
-    return rptr_ == wptr_ && full_;
-  }
+  [[nodiscard]] bool full() const override { return rptr_ == wptr_ && full_; }
 
-  [[nodiscard]] bool empty() const override {
-    return rptr_ == wptr_ && !full_;
-  }
+  [[nodiscard]] bool empty() const override { return rptr_ == wptr_ && !full_; }
 
  private:
   void reset() {
@@ -163,9 +160,8 @@ class DynamicBuffer : public Buffer {
         avail = end_ - wptr_;
       } else if (std::cmp_less(end_ - data_.get(), max_size_)) {
         size_t current_size = end_ - data_.get();
-        size_t new_size = std::min(max_size_,
-                                   current_size + std::max(need - avail,
-                                                           current_size));
+        size_t new_size = std::min(
+            max_size_, current_size + std::max(need - avail, current_size));
         auto tmp = std::make_unique_for_overwrite<char[]>(new_size);
         memcpy(tmp.get(), rptr_, wptr_ - rptr_);
         end_ = tmp.get() + new_size;
@@ -185,12 +181,10 @@ class DynamicBuffer : public Buffer {
 
   [[nodiscard]] bool full() const override {
     return rptr_ == data_.get() && wptr_ == end_ &&
-        std::cmp_equal(end_ - data_.get(), max_size_);
+           std::cmp_equal(end_ - data_.get(), max_size_);
   }
 
-  [[nodiscard]] bool empty() const override {
-    return rptr_ == wptr_;
-  }
+  [[nodiscard]] bool empty() const override { return rptr_ == wptr_; }
 
  private:
   void reset() {
diff --git a/src/check.hh b/src/check.hh
index be65437..91c1717 100644
--- a/src/check.hh
+++ b/src/check.hh
@@ -7,8 +7,8 @@
 
 namespace check {
 
-template<typename T>
-requires std::is_arithmetic_v<T>
+template <typename T>
+  requires std::is_arithmetic_v<T>
 T add(T a, T b) {
   T ret;
   if (ckd_add(&ret, a, b))
@@ -16,8 +16,8 @@ T add(T a, T b) {
   return ret;
 }
 
-template<typename T>
-requires std::is_arithmetic_v<T>
+template <typename T>
+  requires std::is_arithmetic_v<T>
 T sub(T a, T b) {
   T ret;
   if (ckd_sub(&ret, a, b))
@@ -25,8 +25,8 @@ T sub(T a, T b) {
   return ret;
 }
 
-template<typename T>
-requires std::is_arithmetic_v<T>
+template <typename T>
+  requires std::is_arithmetic_v<T>
 T mul(T a, T b) {
   T ret;
   if (ckd_mul(&ret, a, b))
diff --git a/src/csv.cc b/src/csv.cc
index 4135555..c3b2562 100644
--- a/src/csv.cc
+++ b/src/csv.cc
@@ -18,8 +18,7 @@ namespace {
 class ReaderImpl : public Reader {
  public:
   ReaderImpl(std::unique_ptr<line::Reader> reader, char separator)
-      : reader_(std::move(reader)), separator_(separator) {
-  }
+      : reader_(std::move(reader)), separator_(separator) {}
 
   [[nodiscard]]
   std::expected<std::span<std::string_view>, io::ReadError> read() override {
@@ -38,9 +37,7 @@ class ReaderImpl : public Reader {
     }
   }
 
-  [[nodiscard]] uint64_t number() const override {
-    return reader_->number();
-  }
+  [[nodiscard]] uint64_t number() const override { return reader_->number(); }
 
  private:
   std::unique_ptr<line::Reader> reader_;
diff --git a/src/csv.hh b/src/csv.hh
index 8c47ceb..de9ed8c 100644
--- a/src/csv.hh
+++ b/src/csv.hh
@@ -1,7 +1,7 @@
 #ifndef CSV_HH
 #define CSV_HH
 
-#include "io.hh" // IWYU pragma: export
+#include "io.hh"  // IWYU pragma: export
 #include "line.hh"
 
 #include <expected>
diff --git a/src/decompress.hh b/src/decompress.hh
index a15efdc..fa9ffa1 100644
--- a/src/decompress.hh
+++ b/src/decompress.hh
@@ -1,7 +1,7 @@
 #ifndef DECOMPRESS_HH
 #define DECOMPRESS_HH
 
-#include "io.hh" // IWYU pragma: export
+#include "io.hh"  // IWYU pragma: export
 
 namespace decompress {
 
diff --git a/src/decompress_lzma.cc b/src/decompress_lzma.cc
index 299803d..6ba2976 100644
--- a/src/decompress_lzma.cc
+++ b/src/decompress_lzma.cc
@@ -2,13 +2,12 @@
 
 #include "buffer.hh"
 
-#include <lzma.h>
-
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <expected>
+#include <lzma.h>
 #include <memory>
 #include <optional>
 #include <utility>
diff --git a/src/decompress_z.cc b/src/decompress_z.cc
index e888e77..491eff7 100644
--- a/src/decompress_z.cc
+++ b/src/decompress_z.cc
@@ -3,8 +3,6 @@
 #include "buffer.hh"
 
 #define ZLIB_CONST
-#include <zlib.h>
-
 #include <algorithm>
 #include <cstddef>
 #include <expected>
@@ -12,6 +10,7 @@
 #include <memory>
 #include <optional>
 #include <utility>
+#include <zlib.h>
 
 namespace decompress {
 
@@ -116,12 +115,13 @@ class DecompressReader : public io::Reader {
 }  // namespace
 
 std::unique_ptr<io::Reader> zlib(std::unique_ptr<io::Reader> reader) {
-  return std::make_unique<DecompressReader>(std::move(reader), /* gzip = */ false);
+  return std::make_unique<DecompressReader>(std::move(reader),
+                                            /* gzip = */ false);
 }
 
 std::unique_ptr<io::Reader> gzip(std::unique_ptr<io::Reader> reader) {
-  return std::make_unique<DecompressReader>(std::move(reader), /* gzip = */ true);
+  return std::make_unique<DecompressReader>(std::move(reader),
+                                            /* gzip = */ true);
 }
 
-
 }  // namespace decompress
diff --git a/src/gen_ugc.cc b/src/gen_ugc.cc
index 7583272..bc7c91b 100644
--- a/src/gen_ugc.cc
+++ b/src/gen_ugc.cc
@@ -165,17 +165,17 @@ std::expected<std::pair<uint32_t, u::GeneralCategory>, std::string> parse_row(
   auto category_col = row[2];
 
   uint32_t code;
-  auto [ptr, ec] = std::from_chars(code_col.data(),
-                                   code_col.data() + code_col.size(), code,
-                                   /* base */ 16);
+  auto [ptr, ec] =
+      std::from_chars(code_col.data(), code_col.data() + code_col.size(), code,
+                      /* base */ 16);
   if (ec != std::errc() || ptr != code_col.data() + code_col.size()) {
     return std::unexpected(std::format("Invalid code value {}", code_col));
   }
   u::GeneralCategory category;
   auto it = str2gc.find(category_col);
   if (it == str2gc.end()) {
-    return std::unexpected(std::format("Invalid general category {}",
-                                       category_col));
+    return std::unexpected(
+        std::format("Invalid general category {}", category_col));
   }
   category = it->second;
 
@@ -186,9 +186,9 @@ std::expected<std::map<uint32_t, u::GeneralCategory>, std::string> read(
     std::string_view filename) {
   auto maybe_reader = io::open(std::string(filename));
   if (!maybe_reader.has_value()) {
-    return std::unexpected(std::format(
-        "Unable to open {} for reading: {}",
-        filename, ioerr2str(maybe_reader.error())));
+    return std::unexpected(std::format("Unable to open {} for reading: {}",
+                                       filename,
+                                       ioerr2str(maybe_reader.error())));
   }
   auto reader = std::move(maybe_reader.value());
   if (filename.ends_with(".gz")) {
@@ -202,17 +202,17 @@ std::expected<std::map<uint32_t, u::GeneralCategory>, std::string> read(
   while (true) {
     auto row = csv_reader->read();
     if (!row.has_value()) {
-      return std::unexpected(std::format(
-          "{}:{}: Error reading file: {}",
-          filename, csv_reader->number(), ioerr2str(row.error())));
+      return std::unexpected(std::format("{}:{}: Error reading file: {}",
+                                         filename, csv_reader->number(),
+                                         ioerr2str(row.error())));
     }
     if (row->empty())
       break;
 
     auto pair = parse_row(row.value());
     if (!pair.has_value()) {
-      return std::unexpected(std::format(
-          "{}:{}: {}", filename, csv_reader->number(), pair.error()));
+      return std::unexpected(std::format("{}:{}: {}", filename,
+                                         csv_reader->number(), pair.error()));
     }
     auto name_col = (*row)[1];
 
@@ -220,15 +220,15 @@ std::expected<std::map<uint32_t, u::GeneralCategory>, std::string> read(
       std::string prefix(name_col.substr(0, name_col.size() - 8));
       row = csv_reader->read();
       if (!row.has_value()) {
-        return std::unexpected(std::format(
-            "{}:{}: Error reading file: {}",
-            filename, csv_reader->number(), ioerr2str(row.error())));
+        return std::unexpected(std::format("{}:{}: Error reading file: {}",
+                                           filename, csv_reader->number(),
+                                           ioerr2str(row.error())));
       }
 
       auto second_pair = parse_row(row.value());
       if (!pair.has_value()) {
-        return std::unexpected(std::format(
-            "{}:{}: {}", filename, csv_reader->number(), pair.error()));
+        return std::unexpected(std::format("{}:{}: {}", filename,
+                                           csv_reader->number(), pair.error()));
       }
 
       name_col = (*row)[1];
@@ -236,29 +236,29 @@ std::expected<std::map<uint32_t, u::GeneralCategory>, std::string> read(
           name_col.substr(0, name_col.size() - 7) == prefix) {
         if (pair->second != second_pair->second) {
           return std::unexpected(std::format(
-              "{}:{}: Invalid range, general category doesn't match",
-              filename, csv_reader->number()));
+              "{}:{}: Invalid range, general category doesn't match", filename,
+              csv_reader->number()));
         }
 
         for (uint32_t c = pair->first; c <= second_pair->first; ++c) {
           auto emplace_ret = ret.emplace(c, pair->second);
           if (!emplace_ret.second) {
-            return std::unexpected(std::format(
-                "{}:{}: Duplicate value for {:#08x}",
-                filename, csv_reader->number(), c));
+            return std::unexpected(
+                std::format("{}:{}: Duplicate value for {:#08x}", filename,
+                            csv_reader->number(), c));
           }
         }
       } else {
-        return std::unexpected(std::format(
-            "{}:{}: Invalid range, {} doesn't match {}",
-            filename, csv_reader->number(), prefix, name_col));
+        return std::unexpected(
+            std::format("{}:{}: Invalid range, {} doesn't match {}", filename,
+                        csv_reader->number(), prefix, name_col));
       }
     } else {
       auto emplace_ret = ret.emplace(std::move(pair.value()));
       if (!emplace_ret.second) {
-        return std::unexpected(std::format(
-            "{}:{}: Duplicate value for {:#08x}",
-            filename, csv_reader->number(), emplace_ret.first->first));
+        return std::unexpected(std::format("{}:{}: Duplicate value for {:#08x}",
+                                           filename, csv_reader->number(),
+                                           emplace_ret.first->first));
       }
     }
   }
@@ -310,7 +310,7 @@ int main(int argc, char** argv) {
     print_footer(std::cout, prefix);
   } else {
     std::fstream out{std::string(arguments[1]),
-      std::fstream::trunc | std::fstream::out};
+                     std::fstream::trunc | std::fstream::out};
     print_header(out, prefix);
     print_body(out, general_categories.value());
     print_footer(out, prefix);
diff --git a/src/io.cc b/src/io.cc
index e0ab787..14676bc 100644
--- a/src/io.cc
+++ b/src/io.cc
@@ -24,15 +24,14 @@ namespace {
 
 class BasicReader : public Reader {
  public:
-  explicit BasicReader(unique_fd fd)
-      : fd_(std::move(fd)) {
-  }
+  explicit BasicReader(unique_fd fd) : fd_(std::move(fd)) {}
 
   [[nodiscard]]
   std::expected<size_t, ReadError> read(void* dst, size_t max) override {
     ssize_t ret = ::read(
-        fd_.get(), dst, std::min(static_cast<size_t>(
-            std::numeric_limits<ssize_t>::max()), max));
+        fd_.get(), dst,
+        std::min(static_cast<size_t>(std::numeric_limits<ssize_t>::max()),
+                 max));
     if (ret < 0) {
       switch (errno) {
         case EINTR:
@@ -50,8 +49,10 @@ class BasicReader : public Reader {
     off_t ret;
     if (sizeof(size_t) > sizeof(off_t)) {
       // NOLINTNEXTLINE(bugprone-narrowing-conversions)
-      ret = lseek(fd_.get(), std::min(static_cast<size_t>(
-          std::numeric_limits<off_t>::max()), max), SEEK_CUR);
+      ret = lseek(
+          fd_.get(),
+          std::min(static_cast<size_t>(std::numeric_limits<off_t>::max()), max),
+          SEEK_CUR);
     } else {
       ret = lseek(fd_.get(), static_cast<off_t>(max), SEEK_CUR);
     }
@@ -93,9 +94,7 @@ class BasicReader : public Reader {
 
 class MemoryReader : public Reader {
  public:
-  MemoryReader(void* ptr, size_t size)
-      : ptr_(ptr), size_(size) {
-  }
+  MemoryReader(void* ptr, size_t size) : ptr_(ptr), size_(size) {}
 
   [[nodiscard]]
   std::expected<size_t, ReadError> read(void* dst, size_t max) override {
@@ -125,12 +124,9 @@ class MemoryReader : public Reader {
 class MmapReader : public MemoryReader {
  public:
   MmapReader(unique_fd fd, void* ptr, size_t size)
-      : MemoryReader(ptr, size), fd_(std::move(fd)) {
-  }
+      : MemoryReader(ptr, size), fd_(std::move(fd)) {}
 
-  ~MmapReader() override {
-    munmap(ptr_, size_);
-  }
+  ~MmapReader() override { munmap(ptr_, size_); }
 
  private:
   unique_fd fd_;
diff --git a/src/line.cc b/src/line.cc
index 2eeb116..8ee7134 100644
--- a/src/line.cc
+++ b/src/line.cc
@@ -20,16 +20,19 @@ const char kLineTerminators[] = "\r\n";
 class ReaderImpl : public Reader {
  public:
   ReaderImpl(std::unique_ptr<io::Reader> reader, size_t max_len)
-      : reader_(std::move(reader)), max_len_(max_len),
+      : reader_(std::move(reader)),
+        max_len_(max_len),
         buffer_(std::make_unique_for_overwrite<char[]>(
             check::add(max_len, static_cast<size_t>(2)))),
-        rptr_(buffer_.get()), wptr_(buffer_.get()), search_(rptr_),
+        rptr_(buffer_.get()),
+        wptr_(buffer_.get()),
+        search_(rptr_),
         end_(buffer_.get() + check::add(max_len, static_cast<size_t>(2))) {}
 
   [[nodiscard]] std::expected<std::string_view, ReadError> read() override {
     while (true) {
-      search_ = std::find_first_of(search_, wptr_,
-                                   kLineTerminators, kLineTerminators + 2);
+      search_ = std::find_first_of(search_, wptr_, kLineTerminators,
+                                   kLineTerminators + 2);
       if (search_ < wptr_) {
         if (std::cmp_greater(search_ - rptr_, max_len_)) {
           return line(max_len_, 0);
@@ -91,9 +94,11 @@ class ReaderImpl : public Reader {
 
   void make_space_if_needed() {
     size_t free = rptr_ - buffer_.get();
-    if (free == 0) return;
+    if (free == 0)
+      return;
     size_t avail = end_ - wptr_;
-    if (avail > 1024) return;
+    if (avail > 1024)
+      return;
     memmove(buffer_.get(), rptr_, wptr_ - rptr_);
     search_ -= free;
     wptr_ -= free;
@@ -119,11 +124,9 @@ class ReaderImpl : public Reader {
 
 }  // namespace
 
-ReadError::ReadError()
-    : eof(true) {}
+ReadError::ReadError() : eof(true) {}
 
-ReadError::ReadError(io::ReadError error)
-    : eof(false), io_error(error) {}
+ReadError::ReadError(io::ReadError error) : eof(false), io_error(error) {}
 
 std::unique_ptr<Reader> open(std::unique_ptr<io::Reader> reader,
                              size_t max_len) {
diff --git a/src/line.hh b/src/line.hh
index 94e3646..5ce42dd 100644
--- a/src/line.hh
+++ b/src/line.hh
@@ -1,7 +1,7 @@
 #ifndef LINE_HH
 #define LINE_HH
 
-#include "io.hh" // IWYU pragma: export
+#include "io.hh"  // IWYU pragma: export
 
 #include <cstddef>
 #include <expected>
diff --git a/src/main.cc b/src/main.cc
index 27b4854..a1c8cd5 100644
--- a/src/main.cc
+++ b/src/main.cc
@@ -1,8 +1,8 @@
-#include <iostream>
-
 #include "args.hh"
 #include "config.h"
 
+#include <iostream>
+
 #ifndef VERSION
 # define VERSION "unknown"
 #endif
diff --git a/src/str.cc b/src/str.cc
index f81617d..bd7a654 100644
--- a/src/str.cc
+++ b/src/str.cc
@@ -24,8 +24,8 @@ void split(std::string_view str, std::vector<std::string_view>& out,
   }
 }
 
-std::vector<std::string_view> split(std::string_view str,
-                                    char separator, bool keep_empty) {
+std::vector<std::string_view> split(std::string_view str, char separator,
+                                    bool keep_empty) {
   std::vector<std::string_view> vec;
   split(str, vec, separator, keep_empty);
   return vec;
diff --git a/src/u.hh b/src/u.hh
index 7cf835b..524b2ff 100644
--- a/src/u.hh
+++ b/src/u.hh
@@ -1,19 +1,19 @@
 #ifndef U_HH
 #define U_HH
 
-#include "ugc.hh" // IWYU pragma: export
+#include "ugc.hh"  // IWYU pragma: export
 
 namespace u {
 
 enum class ReadError : uint8_t {
-  Invalid,    // Invalid sequence
-  End,        // At end (it == end)
-  Incomplete, // Too few bytes
+  Invalid,     // Invalid sequence
+  End,         // At end (it == end)
+  Incomplete,  // Too few bytes
 };
 
 enum class ReadErrorReplace : uint8_t {
-  End,        // At end (it == end)
-  Incomplete, // Too few bytes
+  End,         // At end (it == end)
+  Incomplete,  // Too few bytes
 };
 
 enum class Version : uint8_t {
diff --git a/src/u16.hh b/src/u16.hh
index d6a3672..70ba157 100644
--- a/src/u16.hh
+++ b/src/u16.hh
@@ -1,9 +1,9 @@
 #ifndef U16_HH
 #define U16_HH
 
-#include "u.hh" // IWYU pragma: export
+#include "u.hh"  // IWYU pragma: export
 
-#include <cstdint> // IWYU pragma: export
+#include <cstdint>  // IWYU pragma: export
 #include <expected>
 #include <iterator>
 #include <type_traits>
@@ -11,10 +11,11 @@
 
 namespace u16 {
 
-template<std::forward_iterator T>
+template <std::forward_iterator T>
   requires std::is_same_v<std::iter_value_t<T>, uint16_t>
 std::expected<uint32_t, u::ReadError> read(T& start, const T& end) {
-  if (start == end) return std::unexpected(u::ReadError::End);
+  if (start == end)
+    return std::unexpected(u::ReadError::End);
   uint16_t u = *start;
   if (u >= 0xd800 && u <= 0xdbff) {
     if (std::distance(start, end) < 2) {
@@ -35,7 +36,7 @@ std::expected<uint32_t, u::ReadError> read(T& start, const T& end) {
   return u;
 }
 
-template<std::forward_iterator T>
+template <std::forward_iterator T>
   requires std::is_same_v<std::iter_value_t<T>, uint16_t>
 std::expected<uint32_t, u::ReadErrorReplace> read_replace(T& start,
                                                           const T& end,
@@ -58,14 +59,16 @@ std::expected<uint32_t, u::ReadErrorReplace> read_replace(T& start,
   return 0xfffd;
 }
 
-template<std::forward_iterator T>
+template <std::forward_iterator T>
   requires std::is_same_v<std::iter_value_t<T>, uint16_t>
 bool write(T& start, const T& end, uint32_t code) {
   if (code < 0x10000) {
-    if (start == end) return false;
+    if (start == end)
+      return false;
     *start = static_cast<uint16_t>(code);
   } else {
-    if (std::distance(start, end) < 2) return false;
+    if (std::distance(start, end) < 2)
+      return false;
     code -= 0x10000;
     *start = static_cast<uint16_t>(0xd800 + (code >> 10));
     std::advance(start, 1);
@@ -75,12 +78,14 @@ bool write(T& start, const T& end, uint32_t code) {
   return true;
 }
 
-template<std::forward_iterator T>
+template <std::forward_iterator T>
   requires std::is_same_v<std::iter_value_t<T>, uint16_t>
 bool skip(T& start, const T& end) {
-  if (start == end) return false;
+  if (start == end)
+    return false;
   if (*start >= 0xd800 && *start <= 0xdbff) {
-    if (std::distance(start, end) < 2) return false;
+    if (std::distance(start, end) < 2)
+      return false;
     std::advance(start, 2);
     return true;
   }
diff --git a/src/u8.hh b/src/u8.hh
index b89f80f..5292602 100644
--- a/src/u8.hh
+++ b/src/u8.hh
@@ -1,9 +1,9 @@
 #ifndef U8_HH
 #define U8_HH
 
-#include "u.hh" // IWYU pragma: export
+#include "u.hh"  // IWYU pragma: export
 
-#include <cstdint> // IWYU pragma: export
+#include <cstdint>  // IWYU pragma: export
 #include <expected>
 #include <iterator>
 #include <type_traits>
@@ -11,10 +11,11 @@
 
 namespace u8 {
 
-template<std::forward_iterator T>
+template <std::forward_iterator T>
   requires std::is_same_v<std::iter_value_t<T>, uint8_t>
 std::expected<uint32_t, u::ReadError> read(T& start, const T& end) {
-  if (start == end) return std::unexpected(u::ReadError::End);
+  if (start == end)
+    return std::unexpected(u::ReadError::End);
   uint32_t u;
   switch (*start >> 4) {
     case 0xf:
@@ -102,7 +103,7 @@ std::expected<uint32_t, u::ReadError> read(T& start, const T& end) {
   return u;
 }
 
-template<std::forward_iterator T>
+template <std::forward_iterator T>
   requires std::is_same_v<std::iter_value_t<T>, uint8_t>
 std::expected<uint32_t, u::ReadErrorReplace> read_replace(T& start,
                                                           const T& end,
@@ -125,26 +126,30 @@ std::expected<uint32_t, u::ReadErrorReplace> read_replace(T& start,
   return 0xfffd;
 }
 
-template<std::forward_iterator T>
+template <std::forward_iterator T>
   requires std::is_same_v<std::iter_value_t<T>, uint8_t>
 bool write(T& start, const T& end, uint32_t code) {
   if (code < 0x80) {
-    if (start == end) return false;
+    if (start == end)
+      return false;
     *start = static_cast<uint8_t>(code);
   } else if (code < 0x800) {
-    if (std::distance(start, end) < 2) return false;
+    if (std::distance(start, end) < 2)
+      return false;
     *start = 0xc0 | static_cast<uint8_t>(code >> 6);
     std::advance(start, 1);
     *start = 0x80 | static_cast<uint8_t>(code & 0x3f);
   } else if (code < 0x10000) {
-    if (std::distance(start, end) < 3) return false;
+    if (std::distance(start, end) < 3)
+      return false;
     *start = 0xe0 | static_cast<uint8_t>(code >> 12);
     std::advance(start, 1);
     *start = 0x80 | static_cast<uint8_t>((code >> 6) & 0x3f);
     std::advance(start, 1);
     *start = 0x80 | static_cast<uint8_t>(code & 0x3f);
   } else {
-    if (std::distance(start, end) < 4) return false;
+    if (std::distance(start, end) < 4)
+      return false;
     *start = 0xf0 | static_cast<uint8_t>(code >> 18);
     std::advance(start, 1);
     *start = 0x80 | static_cast<uint8_t>((code >> 12) & 0x3f);
@@ -157,22 +162,26 @@ bool write(T& start, const T& end, uint32_t code) {
   return true;
 }
 
-template<std::forward_iterator T>
+template <std::forward_iterator T>
   requires std::is_same_v<std::iter_value_t<T>, uint8_t>
 bool skip(T& start, const T& end) {
-  if (start == end) return false;
+  if (start == end)
+    return false;
   switch (*start >> 4) {
     case 0xf:
-      if (std::distance(start, end) < 4) return false;
+      if (std::distance(start, end) < 4)
+        return false;
       std::advance(start, 4);
       break;
     case 0xe:
-      if (std::distance(start, end) < 3) return false;
+      if (std::distance(start, end) < 3)
+        return false;
       std::advance(start, 3);
       break;
     case 0xc:
     case 0xd:
-      if (std::distance(start, end) < 2) return false;
+      if (std::distance(start, end) < 2)
+        return false;
       std::advance(start, 2);
       break;
     default:
diff --git a/src/uio.cc b/src/uio.cc
index 1bf5e40..475d793 100644
--- a/src/uio.cc
+++ b/src/uio.cc
@@ -1,8 +1,8 @@
 #include "uio.hh"
 
 #include "buffer.hh"
-#include "u8.hh"
 #include "u16.hh"
+#include "u8.hh"
 
 #include <bit>
 #include <cassert>
@@ -16,20 +16,18 @@
 namespace {
 
 constexpr u::ReaderInputFormat kU16NativeInputFormat =
-    (std::endian::native == std::endian::big)
-    ? u::ReaderInputFormat::UTF16_BE
-    : u::ReaderInputFormat::UTF16_LE;
+    (std::endian::native == std::endian::big) ? u::ReaderInputFormat::UTF16_BE
+                                              : u::ReaderInputFormat::UTF16_LE;
 
 constexpr u::ReaderInputFormat kU16SwapInputFormat =
-    (std::endian::native == std::endian::big)
-    ? u::ReaderInputFormat::UTF16_LE
-    : u::ReaderInputFormat::UTF16_BE;
+    (std::endian::native == std::endian::big) ? u::ReaderInputFormat::UTF16_LE
+                                              : u::ReaderInputFormat::UTF16_BE;
 
 constexpr size_t kByteBufferSize = 65535;
 constexpr size_t kUnicodeBufferSize = 8192;
 constexpr size_t kUSwapBufferSize = kByteBufferSize / 4;
 
-template<typename UReader, typename UWriter>
+template <typename UReader, typename UWriter>
 class UnicodeReader : public io::Reader {
  public:
   UnicodeReader(std::unique_ptr<io::Reader> in, u::ReaderConfig config)
@@ -41,8 +39,7 @@ class UnicodeReader : public io::Reader {
       return std::unexpected(err.value());
 
     auto* in = reinterpret_cast<uint8_t const*>(in_ptr_);
-    auto read_err = reader_(in, in + in_avail_, in_eof_,
-                            u_buffer_wptr_,
+    auto read_err = reader_(in, in + in_avail_, in_eof_, u_buffer_wptr_,
                             u_buffer_ + kUnicodeBufferSize);
     byte_buffer_->consume(in - reinterpret_cast<uint8_t const*>(in_ptr_));
     if (read_err.has_value()) {
@@ -84,7 +81,8 @@ class UnicodeReader : public io::Reader {
       u_buffer_wptr_ = u_buffer_;
     } else if (u_out == u_buffer_) {
       // Unable to write anything.
-      if (max == 0) return 0;
+      if (max == 0)
+        return 0;
       return std::unexpected(io::ReadError::MaxTooSmall);
     } else {
       size_t left = u_buffer_wptr_ - u_out;
@@ -132,10 +130,9 @@ class UnicodeReader : public io::Reader {
 };
 
 struct U8ReaderStrict {
-  std::optional<u::ReadError> operator()(uint8_t const* &in,
+  std::optional<u::ReadError> operator()(uint8_t const*& in,
                                          uint8_t const* in_end,
-                                         bool /* in_eof */,
-                                         uint32_t* &out,
+                                         bool /* in_eof */, uint32_t*& out,
                                          uint32_t const* out_end) {
     std::optional<u::ReadError> ret;
     while (out < out_end) {
@@ -154,9 +151,9 @@ struct U8ReaderStrict {
 };
 
 struct U8Reader {
-  std::optional<u::ReadError> operator()(uint8_t const* &in,
-                                         uint8_t const* in_end,
-                                         bool in_eof, uint32_t* &out,
+  std::optional<u::ReadError> operator()(uint8_t const*& in,
+                                         uint8_t const* in_end, bool in_eof,
+                                         uint32_t*& out,
                                          uint32_t const* out_end) {
     std::optional<u::ReadError> ret;
     while (out < out_end) {
@@ -180,10 +177,9 @@ struct U8Reader {
 };
 
 struct U16NativeReaderStrict {
-  std::optional<u::ReadError> operator()(uint8_t const* &in,
+  std::optional<u::ReadError> operator()(uint8_t const*& in,
                                          uint8_t const* in_end,
-                                         bool /* in_eof */,
-                                         uint32_t* &out,
+                                         bool /* in_eof */, uint32_t*& out,
                                          uint32_t const* out_end) {
     auto* it = reinterpret_cast<uint16_t const*>(in);
     auto* const end = it + ((in_end - in) / 2);
@@ -207,10 +203,9 @@ struct U16NativeReaderStrict {
 };
 
 struct U16SwapReaderStrict {
-  std::optional<u::ReadError> operator()(uint8_t const* &in,
+  std::optional<u::ReadError> operator()(uint8_t const*& in,
                                          uint8_t const* in_end,
-                                         bool /* in_eof */,
-                                         uint32_t* &out,
+                                         bool /* in_eof */, uint32_t*& out,
                                          uint32_t const* out_end) {
     auto* it = buffer_;
     auto* const end = it + ((in_end - in) / 2);
@@ -218,7 +213,8 @@ struct U16SwapReaderStrict {
       return u::ReadError::Incomplete;
     {
       auto* in2 = reinterpret_cast<uint16_t const*>(in);
-      for (auto* it2 = it; it2 != end; ++it2) *it2 = std::byteswap(*(in2++));
+      for (auto* it2 = it; it2 != end; ++it2)
+        *it2 = std::byteswap(*(in2++));
     }
     std::optional<u::ReadError> ret;
     while (out < out_end) {
@@ -241,10 +237,9 @@ struct U16SwapReaderStrict {
 };
 
 struct U16NativeReader {
-  std::optional<u::ReadError> operator()(uint8_t const* &in,
-                                         uint8_t const* in_end,
-                                         bool in_eof,
-                                         uint32_t* &out,
+  std::optional<u::ReadError> operator()(uint8_t const*& in,
+                                         uint8_t const* in_end, bool in_eof,
+                                         uint32_t*& out,
                                          uint32_t const* out_end) {
     auto* it = reinterpret_cast<uint16_t const*>(in);
     auto* const end = it + ((in_end - in) / 2);
@@ -281,10 +276,9 @@ struct U16NativeReader {
 };
 
 struct U16SwapReader {
-  std::optional<u::ReadError> operator()(uint8_t const* &in,
-                                         uint8_t const* in_end,
-                                         bool in_eof,
-                                         uint32_t* &out,
+  std::optional<u::ReadError> operator()(uint8_t const*& in,
+                                         uint8_t const* in_end, bool in_eof,
+                                         uint32_t*& out,
                                          uint32_t const* out_end) {
     auto* it = buffer_;
     auto* const end = it + ((in_end - in) / 2);
@@ -300,7 +294,8 @@ struct U16SwapReader {
     }
     {
       auto* in2 = reinterpret_cast<uint16_t const*>(in);
-      for (auto* it2 = it; it2 != end; ++it2) *it2 = std::byteswap(*(in2++));
+      for (auto* it2 = it; it2 != end; ++it2)
+        *it2 = std::byteswap(*(in2++));
     }
     std::optional<u::ReadError> ret;
     while (out < out_end) {
@@ -328,7 +323,7 @@ struct U16SwapReader {
 };
 
 bool detect(uint8_t const* in, uint8_t const* in_end, bool in_eof,
-            u::ReaderInputFormat &format) {
+            u::ReaderInputFormat& format) {
   if (in == in_end) {
     if (in_eof) {
       // Doesn't matter, go with UTF-8 just to get out of "detect"
@@ -382,10 +377,9 @@ bool detect(uint8_t const* in, uint8_t const* in_end, bool in_eof,
 }
 
 struct DetectReaderStrict {
-  std::optional<u::ReadError> operator()(uint8_t const* &in,
-                                         uint8_t const* in_end,
-                                         bool in_eof,
-                                         uint32_t* &out,
+  std::optional<u::ReadError> operator()(uint8_t const*& in,
+                                         uint8_t const* in_end, bool in_eof,
+                                         uint32_t*& out,
                                          uint32_t const* out_end) {
     switch (format_) {
       case u::ReaderInputFormat::DETECT:
@@ -411,10 +405,9 @@ struct DetectReaderStrict {
 };
 
 struct DetectReader {
-  std::optional<u::ReadError> operator()(uint8_t const* &in,
-                                         uint8_t const* in_end,
-                                         bool in_eof,
-                                         uint32_t* &out,
+  std::optional<u::ReadError> operator()(uint8_t const*& in,
+                                         uint8_t const* in_end, bool in_eof,
+                                         uint32_t*& out,
                                          uint32_t const* out_end) {
     switch (format_) {
       case u::ReaderInputFormat::DETECT:
@@ -440,8 +433,8 @@ struct DetectReader {
 };
 
 struct U8Writer {
-  bool operator()(uint32_t const* &in, uint32_t const* in_end,
-                  void* &out, size_t out_avail) {
+  bool operator()(uint32_t const*& in, uint32_t const* in_end, void*& out,
+                  size_t out_avail) {
     auto* it = reinterpret_cast<uint8_t*>(out);
     auto* const end = it + out_avail;
     bool ret = true;
@@ -459,8 +452,8 @@ struct U8Writer {
 
 struct U16NativeWriter {
  public:
-  bool operator()(uint32_t const* &in, uint32_t const* in_end,
-                  void* &out, size_t out_avail) {
+  bool operator()(uint32_t const*& in, uint32_t const* in_end, void*& out,
+                  size_t out_avail) {
     auto* it = reinterpret_cast<uint16_t*>(out);
     auto* const end = it + (out_avail / 2);
     bool ret = true;
@@ -505,12 +498,11 @@ namespace u8 {
 
 namespace {
 
-template<typename UReader>
+template <typename UReader>
 class UnicodeReaderU8Writer : public UnicodeReader<UReader, U8Writer>,
                               public virtual Reader {
  public:
-  UnicodeReaderU8Writer(std::unique_ptr<io::Reader> in,
-                        u::ReaderConfig config)
+  UnicodeReaderU8Writer(std::unique_ptr<io::Reader> in, u::ReaderConfig config)
       : UnicodeReader<UReader, U8Writer>(std::move(in), config) {}
 
   std::expected<size_t, io::ReadError> read(void* dst, size_t max) override {
@@ -524,7 +516,6 @@ class UnicodeReaderU8Writer : public UnicodeReader<UReader, U8Writer>,
 
 }  // namespace
 
-
 std::expected<size_t, io::ReadError> Reader::read(std::string& data,
                                                   size_t max) {
   if (max > data.size())
@@ -536,8 +527,8 @@ std::expected<size_t, io::ReadError> Reader::read(std::string& data,
   return ret;
 }
 
-std::expected<size_t, io::ReadError> Reader::repeat_read(
-    std::string& data, size_t max) {
+std::expected<size_t, io::ReadError> Reader::repeat_read(std::string& data,
+                                                         size_t max) {
   if (max > data.size())
     data.resize(max);
   auto ret = repeat_read(data.data(), max);
@@ -547,8 +538,8 @@ std::expected<size_t, io::ReadError> Reader::repeat_read(
   return ret;
 }
 
-std::unique_ptr<Reader> open(
-    std::unique_ptr<io::Reader> reader, u::ReaderConfig config) {
+std::unique_ptr<Reader> open(std::unique_ptr<io::Reader> reader,
+                             u::ReaderConfig config) {
   switch (config.input) {
     case u::ReaderInputFormat::UTF8:
       if (config.strict)
@@ -603,10 +594,10 @@ namespace u16 {
 
 namespace {
 
-template<typename UReader>
-class UnicodeReaderU16NativeWriter : public UnicodeReader<UReader,
-                                                          U16NativeWriter>,
-                                     public virtual Reader {
+template <typename UReader>
+class UnicodeReaderU16NativeWriter
+    : public UnicodeReader<UReader, U16NativeWriter>,
+      public virtual Reader {
  public:
   UnicodeReaderU16NativeWriter(std::unique_ptr<io::Reader> in,
                                u::ReaderConfig config)
@@ -635,8 +626,8 @@ std::expected<size_t, io::ReadError> Reader::read(std::u16string& data,
   return ret;
 }
 
-std::expected<size_t, io::ReadError> Reader::repeat_read(
-    std::u16string& data, size_t max) {
+std::expected<size_t, io::ReadError> Reader::repeat_read(std::u16string& data,
+                                                         size_t max) {
   if (max > data.size())
     data.resize(max);
   auto ret = repeat_read(data.data(), max * 2);
@@ -647,8 +638,8 @@ std::expected<size_t, io::ReadError> Reader::repeat_read(
   return ret;
 }
 
-std::unique_ptr<Reader> open(
-    std::unique_ptr<io::Reader> reader, u::ReaderConfig config) {
+std::unique_ptr<Reader> open(std::unique_ptr<io::Reader> reader,
+                             u::ReaderConfig config) {
   switch (config.input) {
     case u::ReaderInputFormat::UTF8:
       if (config.strict)
@@ -658,22 +649,25 @@ std::unique_ptr<Reader> open(
           std::move(reader), config);
     case kU16NativeInputFormat:
       if (config.strict)
-        return std::make_unique<UnicodeReaderU16NativeWriter<
-          U16NativeReaderStrict>>(std::move(reader), config);
+        return std::make_unique<
+            UnicodeReaderU16NativeWriter<U16NativeReaderStrict>>(
+            std::move(reader), config);
       return std::make_unique<UnicodeReaderU16NativeWriter<U16NativeReader>>(
           std::move(reader), config);
       break;
     case kU16SwapInputFormat:
       if (config.strict)
-        return std::make_unique<UnicodeReaderU16NativeWriter<
-          U16SwapReaderStrict>>(std::move(reader), config);
+        return std::make_unique<
+            UnicodeReaderU16NativeWriter<U16SwapReaderStrict>>(
+            std::move(reader), config);
       return std::make_unique<UnicodeReaderU16NativeWriter<U16SwapReader>>(
           std::move(reader), config);
       break;
     case u::ReaderInputFormat::DETECT:
       if (config.strict)
-        return std::make_unique<UnicodeReaderU16NativeWriter<
-          DetectReaderStrict>>(std::move(reader), config);
+        return std::make_unique<
+            UnicodeReaderU16NativeWriter<DetectReaderStrict>>(std::move(reader),
+                                                              config);
       return std::make_unique<UnicodeReaderU16NativeWriter<DetectReader>>(
           std::move(reader), config);
       break;
diff --git a/src/uio.hh b/src/uio.hh
index a0911a1..3b26351 100644
--- a/src/uio.hh
+++ b/src/uio.hh
@@ -1,7 +1,7 @@
 #ifndef UIO_HH
 #define UIO_HH
 
-#include "io.hh" // IWYU pragma: export
+#include "io.hh"  // IWYU pragma: export
 
 #include <cstddef>
 #include <expected>
@@ -25,7 +25,7 @@ struct ReaderConfig {
   bool skip_bom{true};
 };
 
-}  // namespace u8
+}  // namespace u
 
 namespace u8 {
 
@@ -34,15 +34,15 @@ class Reader : public io::Reader {
   using io::Reader::read;
   using io::Reader::repeat_read;
 
-  [[nodiscard]] std::expected<size_t, io::ReadError> read(
-      std::string& data, size_t max);
+  [[nodiscard]] std::expected<size_t, io::ReadError> read(std::string& data,
+                                                          size_t max);
 
   [[nodiscard]] std::expected<size_t, io::ReadError> repeat_read(
       std::string& data, size_t max);
 };
 
-[[nodiscard]] std::unique_ptr<Reader> open(
-    std::unique_ptr<io::Reader> reader, u::ReaderConfig config = {});
+[[nodiscard]] std::unique_ptr<Reader> open(std::unique_ptr<io::Reader> reader,
+                                           u::ReaderConfig config = {});
 
 [[nodiscard]] std::expected<std::unique_ptr<Reader>, io::OpenError> open(
     const std::string& file_path, u::ReaderConfig config = {});
@@ -58,15 +58,15 @@ class Reader : public io::Reader {
   using io::Reader::read;
   using io::Reader::repeat_read;
 
-  [[nodiscard]] std::expected<size_t, io::ReadError> read(
-      std::u16string& data, size_t max);
+  [[nodiscard]] std::expected<size_t, io::ReadError> read(std::u16string& data,
+                                                          size_t max);
 
   [[nodiscard]] std::expected<size_t, io::ReadError> repeat_read(
       std::u16string& data, size_t max);
 };
 
-[[nodiscard]] std::unique_ptr<Reader> open(
-    std::unique_ptr<io::Reader> reader, u::ReaderConfig config = {});
+[[nodiscard]] std::unique_ptr<Reader> open(std::unique_ptr<io::Reader> reader,
+                                           u::ReaderConfig config = {});
 
 [[nodiscard]] std::expected<std::unique_ptr<Reader>, io::OpenError> open(
     const std::string& file_path, u::ReaderConfig config = {});
diff --git a/src/umod8.hh b/src/umod8.hh
index b91b199..4731942 100644
--- a/src/umod8.hh
+++ b/src/umod8.hh
@@ -1,9 +1,9 @@
 #ifndef UMOD8_HH
 #define UMOD8_HH
 
-#include "u.hh" // IWYU pragma: export
+#include "u.hh"  // IWYU pragma: export
 
-#include <cstdint> // IWYU pragma: export
+#include <cstdint>  // IWYU pragma: export
 #include <expected>
 #include <iterator>
 #include <type_traits>
@@ -11,10 +11,11 @@
 
 namespace umod8 {
 
-template<std::forward_iterator T>
+template <std::forward_iterator T>
   requires std::is_same_v<std::iter_value_t<T>, uint8_t>
 std::expected<uint32_t, u::ReadError> read(T& start, const T& end) {
-  if (start == end) return std::unexpected(u::ReadError::End);
+  if (start == end)
+    return std::unexpected(u::ReadError::End);
   uint32_t u;
   switch (*start >> 4) {
     case 0xe: {
@@ -44,7 +45,8 @@ std::expected<uint32_t, u::ReadError> read(T& start, const T& end) {
         std::advance(start, 1);
         // Not going recursive here as we don't want it unbounded
         // Lone surrogate pair at end == invalid.
-        if (start == end) return std::unexpected(u::ReadError::Invalid);
+        if (start == end)
+          return std::unexpected(u::ReadError::Invalid);
         if ((*start >> 4) == 0xe) {
           if (std::distance(start, end) < 3) {
             start = tmp;
@@ -110,7 +112,7 @@ std::expected<uint32_t, u::ReadError> read(T& start, const T& end) {
   return u;
 }
 
-template<std::forward_iterator T>
+template <std::forward_iterator T>
   requires std::is_same_v<std::iter_value_t<T>, uint8_t>
 std::expected<uint32_t, u::ReadErrorReplace> read_replace(T& start,
                                                           const T& end,
@@ -133,19 +135,22 @@ std::expected<uint32_t, u::ReadErrorReplace> read_replace(T& start,
   return 0xfffd;
 }
 
-template<std::forward_iterator T>
+template <std::forward_iterator T>
   requires std::is_same_v<std::iter_value_t<T>, uint8_t>
 bool write(T& start, const T& end, uint32_t code) {
   if (code > 0 && code < 0x80) {
-    if (start == end) return false;
+    if (start == end)
+      return false;
     *start = static_cast<uint8_t>(code);
   } else if (code < 0x800) {
-    if (std::distance(start, end) < 2) return false;
+    if (std::distance(start, end) < 2)
+      return false;
     *start = 0xc0 | static_cast<uint8_t>(code >> 6);
     std::advance(start, 1);
     *start = 0x80 | static_cast<uint8_t>(code & 0x3f);
   } else if (code < 0x10000) {
-    if (std::distance(start, end) < 3) return false;
+    if (std::distance(start, end) < 3)
+      return false;
     *start = 0xe0 | static_cast<uint8_t>(code >> 12);
     std::advance(start, 1);
     *start = 0x80 | static_cast<uint8_t>((code >> 6) & 0x3f);
@@ -165,20 +170,23 @@ bool write(T& start, const T& end, uint32_t code) {
   return true;
 }
 
-template<std::forward_iterator T>
+template <std::forward_iterator T>
   requires std::is_same_v<std::iter_value_t<T>, uint8_t>
 bool skip(T& start, const T& end) {
-  if (start == end) return false;
+  if (start == end)
+    return false;
   switch (*start >> 4) {
     case 0xe: {
       auto tmp = start;
-      if (read(start, end).has_value()) return true;
+      if (read(start, end).has_value())
+        return true;
       start = tmp;
       return false;
     }
     case 0xc:
     case 0xd:
-      if (std::distance(start, end) < 2) return false;
+      if (std::distance(start, end) < 2)
+        return false;
       std::advance(start, 2);
       break;
     default:
diff --git a/src/unique_fd.hh b/src/unique_fd.hh
index 189d513..2950905 100644
--- a/src/unique_fd.hh
+++ b/src/unique_fd.hh
@@ -3,28 +3,19 @@
 
 class unique_fd {
  public:
-  constexpr unique_fd()
-      : fd_(-1) {}
-  explicit constexpr unique_fd(int fd)
-      : fd_(fd) {}
+  constexpr unique_fd() : fd_(-1) {}
+  explicit constexpr unique_fd(int fd) : fd_(fd) {}
   unique_fd(unique_fd& fd) = delete;
   unique_fd& operator=(unique_fd& fd) = delete;
-  unique_fd(unique_fd&& fd)
-      : fd_(fd.release()) {}
+  unique_fd(unique_fd&& fd) : fd_(fd.release()) {}
   unique_fd& operator=(unique_fd&& fd) {
     reset(fd.release());
     return *this;
   }
-  ~unique_fd() {
-    reset();
-  }
+  ~unique_fd() { reset(); }
 
-  bool operator==(unique_fd const& fd) const {
-    return get() == fd.get();
-  }
-  bool operator!=(unique_fd const& fd) const {
-    return get() != fd.get();
-  }
+  bool operator==(unique_fd const& fd) const { return get() == fd.get(); }
+  bool operator!=(unique_fd const& fd) const { return get() != fd.get(); }
 
   int get() const { return fd_; }
   explicit operator bool() const { return fd_ != -1; }
diff --git a/test/args.cc b/test/args.cc
index a43c59c..22159d2 100644
--- a/test/args.cc
+++ b/test/args.cc
@@ -1,8 +1,7 @@
-#include <gtest/gtest.h>
-
 #include "args.hh"
 
 #include <cstddef>
+#include <gtest/gtest.h>
 #include <memory>
 #include <sstream>
 #include <string>
@@ -10,17 +9,17 @@
 #include <utility>
 #include <vector>
 
-#define SETUP_OPTIONS(args)                                             \
-  auto short_only = (args)->option('a', "", "an option");               \
-  auto short_long = (args)->option('b', "bold", "set font style to bold"); \
-  auto long_only = (args)->option("cold", "use if it is cold outside"); \
-  auto short_only_req = (args)->option_argument('d', "", "", "distance"); \
-  auto short_long_req = (args)->option_argument(                        \
-      'e', "eat", "FOOD", "what to order, what to eat?");               \
-  auto long_only_req = (args)->option_argument(                         \
-      "form", "", "circle, shape or something else?");                  \
-  auto short_only_opt = (args)->option_argument('g', "", "", "", false); \
-  auto short_long_opt = (args)->option_argument('h', "hold", "", "", false); \
+#define SETUP_OPTIONS(args)                                                    \
+  auto short_only = (args)->option('a', "", "an option");                      \
+  auto short_long = (args)->option('b', "bold", "set font style to bold");     \
+  auto long_only = (args)->option("cold", "use if it is cold outside");        \
+  auto short_only_req = (args)->option_argument('d', "", "", "distance");      \
+  auto short_long_req = (args)->option_argument(                               \
+      'e', "eat", "FOOD", "what to order, what to eat?");                      \
+  auto long_only_req =                                                         \
+      (args)->option_argument("form", "", "circle, shape or something else?"); \
+  auto short_only_opt = (args)->option_argument('g', "", "", "", false);       \
+  auto short_long_opt = (args)->option_argument('h', "hold", "", "", false);   \
   auto long_only_opt = (args)->option_argument("invert", "", "", false);
 
 namespace {
@@ -30,8 +29,7 @@ class Arguments {
   [[nodiscard]] int c() const { return static_cast<int>(str_.size()); };
   [[nodiscard]] char** v() const { return ptr_.get(); }
 
-  explicit Arguments(std::vector<std::string> str)
-      : str_(std::move(str)) {
+  explicit Arguments(std::vector<std::string> str) : str_(std::move(str)) {
     ptr_ = std::make_unique<char*[]>(str_.size());
     for (size_t i = 0; i < str_.size(); ++i) {
       ptr_[i] = const_cast<char*>(str_[i].c_str());
@@ -48,9 +46,7 @@ class Arguments {
 
 class Builder {
  public:
-  Arguments build() {
-    return Arguments(std::move(str_));
-  }
+  Arguments build() { return Arguments(std::move(str_)); }
 
   Builder& add(std::string str) {
     str_.emplace_back(std::move(str));
@@ -110,16 +106,18 @@ TEST(args, options_set) {
   SETUP_OPTIONS(args);
   Builder builder;
   auto arg = builder.add("foo")
-             .add("-a")
-             .add("-b")
-             .add("--cold")
-             .add("-d").add("10")
-             .add("-e").add("hamburger")
-             .add("--form=circle")
-             .add("-g")
-             .add("-h")
-             .add("--invert")
-             .build();
+                 .add("-a")
+                 .add("-b")
+                 .add("--cold")
+                 .add("-d")
+                 .add("10")
+                 .add("-e")
+                 .add("hamburger")
+                 .add("--form=circle")
+                 .add("-g")
+                 .add("-h")
+                 .add("--invert")
+                 .build();
   std::vector<std::string_view> out;
   EXPECT_TRUE(args->run(arg.c(), arg.v(), &out));
   EXPECT_TRUE(out.empty());
@@ -148,16 +146,18 @@ TEST(args, options_set_variant) {
   SETUP_OPTIONS(args);
   Builder builder;
   auto arg = builder.add("foo")
-             .add("-a")
-             .add("--bold")
-             .add("--cold")
-             .add("-d").add("10")
-             .add("--eat=hamburger")
-             .add("--form").add("circle")
-             .add("-g")
-             .add("--hold=foo")
-             .add("--invert=bar")
-             .build();
+                 .add("-a")
+                 .add("--bold")
+                 .add("--cold")
+                 .add("-d")
+                 .add("10")
+                 .add("--eat=hamburger")
+                 .add("--form")
+                 .add("circle")
+                 .add("-g")
+                 .add("--hold=foo")
+                 .add("--invert=bar")
+                 .build();
   std::vector<std::string_view> out;
   EXPECT_TRUE(args->run(arg.c(), arg.v(), &out));
   EXPECT_TRUE(out.empty());
@@ -187,9 +187,7 @@ TEST(args, options_short_missing_value) {
   auto args = Args::create();
   SETUP_OPTIONS(args);
   Builder builder;
-  auto arg = builder.add("foo")
-             .add("-d")
-             .build();
+  auto arg = builder.add("foo").add("-d").build();
   EXPECT_FALSE(args->run(arg.c(), arg.v()));
   std::stringstream ss;
   args->print_error(ss);
@@ -200,9 +198,7 @@ TEST(args, options_short_unknown_value) {
   auto args = Args::create();
   SETUP_OPTIONS(args);
   Builder builder;
-  auto arg = builder.add("foo")
-             .add("-X")
-             .build();
+  auto arg = builder.add("foo").add("-X").build();
   EXPECT_FALSE(args->run(arg.c(), arg.v()));
   std::stringstream ss;
   args->print_error(ss);
@@ -213,9 +209,7 @@ TEST(args, options_long_missing_value) {
   auto args = Args::create();
   SETUP_OPTIONS(args);
   Builder builder;
-  auto arg = builder.add("foo")
-             .add("--form")
-             .build();
+  auto arg = builder.add("foo").add("--form").build();
   EXPECT_FALSE(args->run(arg.c(), arg.v()));
   std::stringstream ss;
   args->print_error(ss);
@@ -226,9 +220,7 @@ TEST(args, options_long_unsupported_value) {
   auto args = Args::create();
   SETUP_OPTIONS(args);
   Builder builder;
-  auto arg = builder.add("foo")
-             .add("--cold=feet")
-             .build();
+  auto arg = builder.add("foo").add("--cold=feet").build();
   EXPECT_FALSE(args->run(arg.c(), arg.v()));
   std::stringstream ss;
   args->print_error(ss);
@@ -239,9 +231,7 @@ TEST(args, options_long_unknown_value) {
   auto args = Args::create();
   SETUP_OPTIONS(args);
   Builder builder;
-  auto arg = builder.add("foo")
-             .add("--experience")
-             .build();
+  auto arg = builder.add("foo").add("--experience").build();
   EXPECT_FALSE(args->run(arg.c(), arg.v()));
   std::stringstream ss;
   args->print_error(ss);
@@ -252,9 +242,7 @@ TEST(args, options_short_dash_value) {
   auto args = Args::create();
   SETUP_OPTIONS(args);
   Builder builder;
-  auto arg = builder.add("foo")
-             .add("-d").add("-")
-             .build();
+  auto arg = builder.add("foo").add("-d").add("-").build();
   std::vector<std::string_view> out;
   EXPECT_TRUE(args->run(arg.c(), arg.v(), &out));
   EXPECT_TRUE(out.empty());
@@ -267,9 +255,7 @@ TEST(args, options_long_dash_dash_value) {
   auto args = Args::create();
   SETUP_OPTIONS(args);
   Builder builder;
-  auto arg = builder.add("foo")
-             .add("--eat").add("--")
-             .build();
+  auto arg = builder.add("foo").add("--eat").add("--").build();
   std::vector<std::string_view> out;
   EXPECT_TRUE(args->run(arg.c(), arg.v(), &out));
   EXPECT_TRUE(out.empty());
@@ -283,11 +269,13 @@ TEST(args, options_dash_dash) {
   SETUP_OPTIONS(args);
   Builder builder;
   auto arg = builder.add("foo")
-             .add("--")
-             .add("-d").add("10")
-             .add("--eat=hamburger")
-             .add("--form").add("circle")
-             .build();
+                 .add("--")
+                 .add("-d")
+                 .add("10")
+                 .add("--eat=hamburger")
+                 .add("--form")
+                 .add("circle")
+                 .build();
   std::vector<std::string_view> out;
   EXPECT_TRUE(args->run(arg.c(), arg.v(), &out));
   ASSERT_EQ(5, out.size());
@@ -305,9 +293,7 @@ TEST(args, options_dash_dash_end) {
   auto args = Args::create();
   SETUP_OPTIONS(args);
   Builder builder;
-  auto arg = builder.add("foo")
-             .add("--")
-             .build();
+  auto arg = builder.add("foo").add("--").build();
   std::vector<std::string_view> out;
   EXPECT_TRUE(args->run(arg.c(), arg.v(), &out));
   EXPECT_TRUE(out.empty());
@@ -330,7 +316,8 @@ TEST(args, help) {
   -g
   -h, --hold=[ARG]
       --invert=[ARG]
-)", ss.str());
+)",
+            ss.str());
 }
 
 TEST(args, help_wide) {
@@ -338,7 +325,8 @@ TEST(args, help_wide) {
   SETUP_OPTIONS(args);
   std::stringstream ss;
   args->print_help(ss, 100);
-  EXPECT_EQ(R"(Mandatory arguments to long options are mandatory for short options too.
+  EXPECT_EQ(
+      R"(Mandatory arguments to long options are mandatory for short options too.
   -a                  an option
   -b, --bold          set font style to bold
       --cold          use if it is cold outside
@@ -348,7 +336,8 @@ TEST(args, help_wide) {
   -g
   -h, --hold=[ARG]
       --invert=[ARG]
-)", ss.str());
+)",
+      ss.str());
 }
 
 TEST(args, help_narrow) {
@@ -372,7 +361,8 @@ circle, shape or something else?
   -g
   -h, --hold=[ARG]
       --invert=[ARG]
-)", ss.str());
+)",
+            ss.str());
 }
 
 TEST(args, help_very_narrow) {
@@ -401,7 +391,8 @@ circle, shape or
   -g
   -h, --hold=[ARG]
       --invert=[ARG]
-)", ss.str());
+)",
+            ss.str());
 }
 
 TEST(args, help_long_word) {
@@ -416,5 +407,6 @@ TEST(args, help_long_word) {
   -a, --arg
 aaaaaaaaaaaaaaaaaaa-
 aaaaaaaaaaaaaaaaaaa
-)", ss.str());
+)",
+            ss.str());
 }
diff --git a/test/buffer.cc b/test/buffer.cc
index e747fb7..897bd88 100644
--- a/test/buffer.cc
+++ b/test/buffer.cc
@@ -1,9 +1,8 @@
-#include <gtest/gtest.h>
-
 #include "buffer.hh"
 
 #include <cstdint>
 #include <cstring>
+#include <gtest/gtest.h>
 #include <memory>
 #include <utility>
 
@@ -240,10 +239,9 @@ TEST_P(BufferTest, full) {
   buffer->consume(0);
 }
 
-INSTANTIATE_TEST_SUITE_P(
-    AllTypes,
-    BufferTest,
-    testing::Values(BufferType::Fixed, BufferType::Dynamic));
+INSTANTIATE_TEST_SUITE_P(AllTypes, BufferTest,
+                         testing::Values(BufferType::Fixed,
+                                         BufferType::Dynamic));
 
 TEST(buffer, dynamic_increase) {
   auto buffer = Buffer::dynamic(10, 20);
diff --git a/test/csv.cc b/test/csv.cc
index 49fe540..b915006 100644
--- a/test/csv.cc
+++ b/test/csv.cc
@@ -1,7 +1,7 @@
-#include <gtest/gtest.h>
-
 #include "csv.hh"
 
+#include <gtest/gtest.h>
+
 TEST(csv, empty) {
   auto csv = csv::open(io::memory(""));
   auto line = csv->read();
diff --git a/test/decompress.cc b/test/decompress.cc
index 35c4477..df1d08c 100644
--- a/test/decompress.cc
+++ b/test/decompress.cc
@@ -1,16 +1,14 @@
-#include <gtest/gtest.h>
-
 #include "decompress.hh"
 
+#include <gtest/gtest.h>
+
 TEST(z_decompress, empty) {
-  static const unsigned char data[] = {
-    0x1f, 0x8b, 0x08, 0x08, 0x33, 0xd4, 0xbd, 0x68,
-    0x02, 0x03, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00
-  };
-  auto reader = decompress::gzip(io::memory(std::string(
-      reinterpret_cast<const char*>(data), sizeof(data))));
+  static const unsigned char data[] = {0x1f, 0x8b, 0x08, 0x08, 0x33, 0xd4, 0xbd,
+                                       0x68, 0x02, 0x03, 0x65, 0x6d, 0x70, 0x74,
+                                       0x79, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+                                       0x00, 0x00, 0x00, 0x00, 0x00};
+  auto reader = decompress::gzip(io::memory(
+      std::string(reinterpret_cast<const char*>(data), sizeof(data))));
   char buf[10];
   auto got = reader->read(buf, sizeof(buf));
   ASSERT_TRUE(got.has_value());
@@ -19,13 +17,12 @@ TEST(z_decompress, empty) {
 
 TEST(z_decompress, hello) {
   static const unsigned char data[] = {
-    0x1f, 0x8b, 0x08, 0x08, 0xf7, 0xd5, 0xbd, 0x68,
-    0x02, 0x03, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00,
-    0xf3, 0x48, 0xcd, 0xc9, 0xc9, 0x07, 0x00, 0x82,
-    0x89, 0xd1, 0xf7, 0x05, 0x00, 0x00, 0x00,
+    0x1f, 0x8b, 0x08, 0x08, 0xf7, 0xd5, 0xbd, 0x68, 0x02, 0x03, 0x68,
+    0x65, 0x6c, 0x6c, 0x6f, 0x00, 0xf3, 0x48, 0xcd, 0xc9, 0xc9, 0x07,
+    0x00, 0x82, 0x89, 0xd1, 0xf7, 0x05, 0x00, 0x00, 0x00,
   };
-  auto reader = decompress::gzip(io::memory(std::string(
-      reinterpret_cast<const char*>(data), sizeof(data))));
+  auto reader = decompress::gzip(io::memory(
+      std::string(reinterpret_cast<const char*>(data), sizeof(data))));
   char buf[10];
   auto got = reader->read(buf, sizeof(buf));
   ASSERT_TRUE(got.has_value());
@@ -36,13 +33,11 @@ TEST(z_decompress, hello) {
 
 TEST(xz_decompress, empty) {
   static const unsigned char data[] = {
-    0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00, 0x00, 0x04,
-    0xe6, 0xd6, 0xb4, 0x46, 0x00, 0x00, 0x00, 0x00,
-    0x1c, 0xdf, 0x44, 0x21, 0x1f, 0xb6, 0xf3, 0x7d,
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x04, 0x59, 0x5a
-  };
-  auto reader = decompress::xz(io::memory(std::string(
-      reinterpret_cast<const char*>(data), sizeof(data))));
+    0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00, 0x00, 0x04, 0xe6, 0xd6, 0xb4,
+    0x46, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xdf, 0x44, 0x21, 0x1f, 0xb6,
+    0xf3, 0x7d, 0x01, 0x00, 0x00, 0x00, 0x00, 0x04, 0x59, 0x5a};
+  auto reader = decompress::xz(io::memory(
+      std::string(reinterpret_cast<const char*>(data), sizeof(data))));
   char buf[10];
   auto got = reader->read(buf, sizeof(buf));
   ASSERT_TRUE(got.has_value());
@@ -51,18 +46,15 @@ TEST(xz_decompress, empty) {
 
 TEST(xz_decompress, hello) {
   static const unsigned char data[] = {
-    0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00, 0x00, 0x04,
-    0xe6, 0xd6, 0xb4, 0x46, 0x04, 0xc0, 0x09, 0x05,
-    0x21, 0x01, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x76, 0xe9, 0x07, 0x70,
-    0x01, 0x00, 0x04, 0x48, 0x65, 0x6c, 0x6c, 0x6f,
-    0x00, 0x00, 0x00, 0x00, 0xc8, 0xac, 0x7b, 0xc8,
-    0x3b, 0x5c, 0xcf, 0x51, 0x00, 0x01, 0x25, 0x05,
-    0x43, 0x91, 0x1f, 0xb8, 0x1f, 0xb6, 0xf3, 0x7d,
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x04, 0x59, 0x5a,
+    0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00, 0x00, 0x04, 0xe6, 0xd6, 0xb4, 0x46,
+    0x04, 0xc0, 0x09, 0x05, 0x21, 0x01, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x76, 0xe9, 0x07, 0x70, 0x01, 0x00, 0x04, 0x48,
+    0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xac, 0x7b, 0xc8,
+    0x3b, 0x5c, 0xcf, 0x51, 0x00, 0x01, 0x25, 0x05, 0x43, 0x91, 0x1f, 0xb8,
+    0x1f, 0xb6, 0xf3, 0x7d, 0x01, 0x00, 0x00, 0x00, 0x00, 0x04, 0x59, 0x5a,
   };
-  auto reader = decompress::xz(io::memory(std::string(
-      reinterpret_cast<const char*>(data), sizeof(data))));
+  auto reader = decompress::xz(io::memory(
+      std::string(reinterpret_cast<const char*>(data), sizeof(data))));
   char buf[10];
   auto got = reader->read(buf, sizeof(buf));
   ASSERT_TRUE(got.has_value());
diff --git a/test/io.cc b/test/io.cc
index d6e5161..843c83e 100644
--- a/test/io.cc
+++ b/test/io.cc
@@ -1,12 +1,12 @@
-#include <gtest/gtest.h>
-
 #include "io.hh"
+
 #include "io_test_helper.hh"
 
 #include <cerrno>
 #include <cstdlib>
 #include <dirent.h>
 #include <fcntl.h>
+#include <gtest/gtest.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <utility>
@@ -15,11 +15,14 @@ namespace {
 
 bool remove_recursive(int fd) {
   auto* dir = fdopendir(fd);
-  if (!dir) return false;
+  if (!dir)
+    return false;
   while (auto* ent = readdir(dir)) {
     if (ent->d_name[0] == '.') {
-      if (ent->d_name[1] == '\0') continue;
-      if (ent->d_name[1] == '.' && ent->d_name[2] == '\0') continue;
+      if (ent->d_name[1] == '\0')
+        continue;
+      if (ent->d_name[1] == '.' && ent->d_name[2] == '\0')
+        continue;
     }
     bool is_dir;
     if (ent->d_type == DT_DIR) {
@@ -86,14 +89,13 @@ class IoTest : public testing::Test {
     rmdir(tmpdir_.c_str());
   }
 
-  [[nodiscard]] int dirfd() const {
-    return dirfd_;
-  }
+  [[nodiscard]] int dirfd() const { return dirfd_; }
 
   void touch(const std::string& name, const std::string& value = "") {
     auto fd = openat(dirfd(), name.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0700);
     EXPECT_NE(-1, fd);
-    if (fd == -1) return;
+    if (fd == -1)
+      return;
     size_t offset = 0;
     while (offset < value.size()) {
       auto ret = write(fd, value.data() + offset, value.size() - offset);
diff --git a/test/io_test_helper.cc b/test/io_test_helper.cc
index 514e888..9ac663a 100644
--- a/test/io_test_helper.cc
+++ b/test/io_test_helper.cc
@@ -70,9 +70,9 @@ class MaxBlockReader : public io::Reader {
 
 }  // namespace
 
-std::unique_ptr<io::Reader> io_make_breaking(
-    std::unique_ptr<io::Reader> reader, size_t offset,
-    io::ReadError error) {
+std::unique_ptr<io::Reader> io_make_breaking(std::unique_ptr<io::Reader> reader,
+                                             size_t offset,
+                                             io::ReadError error) {
   return std::make_unique<BreakingReader>(std::move(reader), offset, error);
 }
 
diff --git a/test/io_test_helper.hh b/test/io_test_helper.hh
index ce191cf..b99b8fa 100644
--- a/test/io_test_helper.hh
+++ b/test/io_test_helper.hh
@@ -1,7 +1,7 @@
 #ifndef IO_TEST_HELPER_HH
 #define IO_TEST_HELPER_HH
 
-#include "io.hh" // IWYU pragma: export
+#include "io.hh"  // IWYU pragma: export
 
 #include <cstddef>
 #include <memory>
diff --git a/test/line.cc b/test/line.cc
index 0f90723..71d75c5 100644
--- a/test/line.cc
+++ b/test/line.cc
@@ -1,9 +1,9 @@
-#include <gtest/gtest.h>
+#include "line.hh"
 
 #include "io_test_helper.hh"
-#include "line.hh"
 
 #include <cstddef>
+#include <gtest/gtest.h>
 #include <limits>
 #include <utility>
 
@@ -124,9 +124,8 @@ TEST(line, read_error_newline) {
 }
 
 TEST(line, blocky) {
-  auto reader = line::open(
-      io_make_max_block(io::memory("foo bar\r\nfim zam"),
-                        /* max_block_size */ 1));
+  auto reader = line::open(io_make_max_block(io::memory("foo bar\r\nfim zam"),
+                                             /* max_block_size */ 1));
   auto line = reader->read();
   ASSERT_TRUE(line.has_value());
   EXPECT_EQ("foo bar", line.value());
@@ -139,9 +138,8 @@ TEST(line, blocky) {
 }
 
 TEST(line, blocky_newline) {
-  auto reader = line::open(
-      io_make_max_block(io::memory("foo bar\r\nfim zam"),
-                        /* max_block_size */ 8));
+  auto reader = line::open(io_make_max_block(io::memory("foo bar\r\nfim zam"),
+                                             /* max_block_size */ 8));
   auto line = reader->read();
   ASSERT_TRUE(line.has_value());
   EXPECT_EQ("foo bar", line.value());
@@ -177,8 +175,10 @@ TEST(line, max_newline) {
 }
 
 TEST(line, max_line_overflow) {
-  EXPECT_DEATH_IF_SUPPORTED({
-    std::ignore = line::open(io::memory(""),
-                             std::numeric_limits<size_t>::max());
-  }, "");
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        std::ignore =
+            line::open(io::memory(""), std::numeric_limits<size_t>::max());
+      },
+      "");
 }
diff --git a/test/str.cc b/test/str.cc
index 35d70d7..1339bb0 100644
--- a/test/str.cc
+++ b/test/str.cc
@@ -1,7 +1,7 @@
-#include <gtest/gtest.h>
-
 #include "str.hh"
 
+#include <gtest/gtest.h>
+
 TEST(str, split) {
   auto ret = str::split("");
   EXPECT_EQ(0, ret.size());
diff --git a/test/u.cc b/test/u.cc
index dc77e7d..d43109b 100644
--- a/test/u.cc
+++ b/test/u.cc
@@ -1,16 +1,14 @@
-#include <gtest/gtest.h>
-
+#include "u16.hh"
 #include "u8.hh"
 #include "umod8.hh"
-#include "u16.hh"
 
+#include <gtest/gtest.h>
 #include <iterator>
 #include <vector>
 
 namespace {
 
-class UnicodeVersionTest : public testing::TestWithParam<u::Version> {
-};
+class UnicodeVersionTest : public testing::TestWithParam<u::Version> {};
 
 }  // namespace
 
@@ -389,8 +387,7 @@ TEST(umod8, examples) {
   }
 }
 
-TEST(umod8, overlong) {
-}
+TEST(umod8, overlong) {}
 
 TEST(umod8, incomplete) {
   {
@@ -709,8 +706,7 @@ TEST_P(UnicodeVersionTest, lookup_gc) {
             u::GeneralCategory::LETTER_TITLECASE);
   EXPECT_EQ(u::lookup_gc(0x374, GetParam()),
             u::GeneralCategory::LETTER_MODIFIER);
-  EXPECT_EQ(u::lookup_gc(0x34ff, GetParam()),
-            u::GeneralCategory::LETTER_OTHER);
+  EXPECT_EQ(u::lookup_gc(0x34ff, GetParam()), u::GeneralCategory::LETTER_OTHER);
 
   EXPECT_EQ(u::lookup_gc(0x483, GetParam()),
             u::GeneralCategory::MARK_NONSPACING);
@@ -719,12 +715,10 @@ TEST_P(UnicodeVersionTest, lookup_gc) {
   EXPECT_EQ(u::lookup_gc(0x20de, GetParam()),
             u::GeneralCategory::MARK_SPACING_ENCLOSING);
 
-  EXPECT_EQ(u::lookup_gc(0xa620, GetParam()),
-            u::GeneralCategory::NUMBER_DIGIT);
+  EXPECT_EQ(u::lookup_gc(0xa620, GetParam()), u::GeneralCategory::NUMBER_DIGIT);
   EXPECT_EQ(u::lookup_gc(0xa6e6, GetParam()),
             u::GeneralCategory::NUMBER_LETTER);
-  EXPECT_EQ(u::lookup_gc(0xa830, GetParam()),
-            u::GeneralCategory::NUMBER_OTHER);
+  EXPECT_EQ(u::lookup_gc(0xa830, GetParam()), u::GeneralCategory::NUMBER_OTHER);
 
   EXPECT_EQ(u::lookup_gc(0xfe33, GetParam()),
             u::GeneralCategory::PUNCTUATION_CONNECTOR);
@@ -741,14 +735,12 @@ TEST_P(UnicodeVersionTest, lookup_gc) {
   EXPECT_EQ(u::lookup_gc(0xff1a, GetParam()),
             u::GeneralCategory::PUNCTUATION_OTHER);
 
-  EXPECT_EQ(u::lookup_gc(0xd7, GetParam()),
-            u::GeneralCategory::SYMBOL_MATH);
+  EXPECT_EQ(u::lookup_gc(0xd7, GetParam()), u::GeneralCategory::SYMBOL_MATH);
   EXPECT_EQ(u::lookup_gc(0x58f, GetParam()),
             u::GeneralCategory::SYMBOL_CURRENCY);
   EXPECT_EQ(u::lookup_gc(0x5e, GetParam()),
             u::GeneralCategory::SYMBOL_MODIFIER);
-  EXPECT_EQ(u::lookup_gc(0xf03, GetParam()),
-            u::GeneralCategory::SYMBOL_OTHER);
+  EXPECT_EQ(u::lookup_gc(0xf03, GetParam()), u::GeneralCategory::SYMBOL_OTHER);
 
   EXPECT_EQ(u::lookup_gc(0x20, GetParam()),
             u::GeneralCategory::SEPARATOR_SPACE);
@@ -757,10 +749,8 @@ TEST_P(UnicodeVersionTest, lookup_gc) {
   EXPECT_EQ(u::lookup_gc(0x2029, GetParam()),
             u::GeneralCategory::SEPARATOR_PARAGRAPH);
 
-  EXPECT_EQ(u::lookup_gc(0xa, GetParam()),
-            u::GeneralCategory::OTHER_CONTROL);
-  EXPECT_EQ(u::lookup_gc(0x202d, GetParam()),
-            u::GeneralCategory::OTHER_FORMAT);
+  EXPECT_EQ(u::lookup_gc(0xa, GetParam()), u::GeneralCategory::OTHER_CONTROL);
+  EXPECT_EQ(u::lookup_gc(0x202d, GetParam()), u::GeneralCategory::OTHER_FORMAT);
   EXPECT_EQ(u::lookup_gc(0xd800, GetParam()),
             u::GeneralCategory::OTHER_SURROGATE);
   EXPECT_EQ(u::lookup_gc(0xdbff, GetParam()),
@@ -775,18 +765,9 @@ TEST_P(UnicodeVersionTest, lookup_gc) {
 }
 
 INSTANTIATE_TEST_SUITE_P(
-    AllVersions,
-    UnicodeVersionTest,
-    testing::Values(
-        u::Version::u6_2_0,
-        u::Version::u8_0_0,
-        u::Version::u10_0_0,
-        u::Version::u11_0_0,
-        u::Version::u12_1_0,
-        u::Version::u13_0_0,
-        u::Version::u14_0_0,
-        u::Version::u15_0_0,
-        u::Version::u15_1_0,
-        u::Version::u16_0_0
-    )
-);
+    AllVersions, UnicodeVersionTest,
+    testing::Values(u::Version::u6_2_0, u::Version::u8_0_0, u::Version::u10_0_0,
+                    u::Version::u11_0_0, u::Version::u12_1_0,
+                    u::Version::u13_0_0, u::Version::u14_0_0,
+                    u::Version::u15_0_0, u::Version::u15_1_0,
+                    u::Version::u16_0_0));
diff --git a/test/uio.cc b/test/uio.cc
index ce666c1..7c8d175 100644
--- a/test/uio.cc
+++ b/test/uio.cc
@@ -1,9 +1,9 @@
-#include <gtest/gtest.h>
+#include "uio.hh"
 
 #include "io.hh"
 #include "io_test_helper.hh"
-#include "uio.hh"
 
+#include <gtest/gtest.h>
 #include <string>
 
 using namespace std::literals::string_literals;
@@ -25,18 +25,23 @@ TEST(uio_u16, empty) {
 }
 
 TEST(uio_u8, sample) {
-  auto uio = u8::open(io::memory("\xf0\x90\x8D\x85" "es"),
-                      u::ReaderConfig{.input=u::ReaderInputFormat::UTF8});
+  auto uio = u8::open(io::memory("\xf0\x90\x8D\x85"
+                                 "es"),
+                      u::ReaderConfig{.input = u::ReaderInputFormat::UTF8});
   std::string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
   EXPECT_EQ(6, ret.value());
-  EXPECT_EQ("\xf0\x90\x8D\x85" "es", tmp);
+  EXPECT_EQ(
+      "\xf0\x90\x8D\x85"
+      "es",
+      tmp);
 }
 
 TEST(uio_u16, sample_be) {
-  auto uio = u16::open(io::memory("\x00\x24\xD8\x01\xDC\x37"s),
-                      u::ReaderConfig{.input=u::ReaderInputFormat::UTF16_BE});
+  auto uio =
+      u16::open(io::memory("\x00\x24\xD8\x01\xDC\x37"s),
+                u::ReaderConfig{.input = u::ReaderInputFormat::UTF16_BE});
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 5);
   ASSERT_TRUE(ret.has_value());
@@ -47,8 +52,9 @@ TEST(uio_u16, sample_be) {
 }
 
 TEST(uio_u16, sample_le) {
-  auto uio = u16::open(io::memory("\x24\x00\x01\xD8\x37\xDC"s),
-                      u::ReaderConfig{.input=u::ReaderInputFormat::UTF16_LE});
+  auto uio =
+      u16::open(io::memory("\x24\x00\x01\xD8\x37\xDC"s),
+                u::ReaderConfig{.input = u::ReaderInputFormat::UTF16_LE});
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 5);
   ASSERT_TRUE(ret.has_value());
@@ -59,12 +65,17 @@ TEST(uio_u16, sample_le) {
 }
 
 TEST(uio_u8, sample_detect) {
-  auto uio = u8::open(io::memory("\xf0\x90\x8D\x85" "es"));
+  auto uio =
+      u8::open(io::memory("\xf0\x90\x8D\x85"
+                          "es"));
   std::string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
   EXPECT_EQ(6, ret.value());
-  EXPECT_EQ("\xf0\x90\x8D\x85" "es", tmp);
+  EXPECT_EQ(
+      "\xf0\x90\x8D\x85"
+      "es",
+      tmp);
 }
 
 TEST(uio_u16, sample_detect_be) {
@@ -92,8 +103,8 @@ TEST(uio_u16, sample_detect_le) {
 TEST(uio_u8, invalid) {
   auto uio = u8::open(io::memory("r\xe4ksm\xf6rg\xe5s"),
                       u::ReaderConfig{
-                        .strict=true,
-                        .input=u::ReaderInputFormat::UTF8,
+                        .strict = true,
+                        .input = u::ReaderInputFormat::UTF8,
                       });
   std::string tmp;
   auto ret = uio->repeat_read(tmp, 20);
@@ -107,7 +118,7 @@ TEST(uio_u8, invalid) {
 
 TEST(uio_u8, invalid_detect) {
   auto uio = u8::open(io::memory("r\xe4ksm\xf6rg\xe5s"),
-                      u::ReaderConfig{.strict=true});
+                      u::ReaderConfig{.strict = true});
   std::string tmp;
   auto ret = uio->repeat_read(tmp, 20);
   ASSERT_TRUE(ret.has_value());
@@ -121,8 +132,8 @@ TEST(uio_u8, invalid_detect) {
 TEST(uio_u8, invalid_replace) {
   auto uio = u8::open(io::memory("r\xe4ksm\xf6rg\xe5s"),
                       u::ReaderConfig{
-                        .strict=false,
-                        .input=u::ReaderInputFormat::UTF8,
+                        .strict = false,
+                        .input = u::ReaderInputFormat::UTF8,
                       });
   std::string tmp;
   auto ret = uio->repeat_read(tmp, 20);
@@ -133,7 +144,7 @@ TEST(uio_u8, invalid_replace) {
 
 TEST(uio_u8, read_error) {
   auto uio = u8::open(io_make_breaking(io::memory("\xef\xbf\xbd"), 1),
-                      u::ReaderConfig{.input=u::ReaderInputFormat::UTF8});
+                      u::ReaderConfig{.input = u::ReaderInputFormat::UTF8});
   std::string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_FALSE(ret.has_value());
@@ -141,8 +152,9 @@ TEST(uio_u8, read_error) {
 }
 
 TEST(uio_u16, read_error) {
-  auto uio = u16::open(io_make_breaking(io::memory("\x00\x24"s), 1),
-                       u::ReaderConfig{.input=u::ReaderInputFormat::UTF16_BE});
+  auto uio =
+      u16::open(io_make_breaking(io::memory("\x00\x24"s), 1),
+                u::ReaderConfig{.input = u::ReaderInputFormat::UTF16_BE});
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_FALSE(ret.has_value());
@@ -150,11 +162,10 @@ TEST(uio_u16, read_error) {
 }
 
 TEST(uio_u8, read_incomplete_strict) {
-  auto uio = u8::open(io::memory("\xef"),
-                      u::ReaderConfig{
-                        .strict=true,
-                        .input=u::ReaderInputFormat::UTF8,
-                      });
+  auto uio = u8::open(io::memory("\xef"), u::ReaderConfig{
+                                            .strict = true,
+                                            .input = u::ReaderInputFormat::UTF8,
+                                          });
   std::string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_FALSE(ret.has_value());
@@ -162,11 +173,10 @@ TEST(uio_u8, read_incomplete_strict) {
 }
 
 TEST(uio_u8, read_incomplete) {
-  auto uio = u8::open(io::memory("\xef"),
-                      u::ReaderConfig{
-                        .strict=false,
-                        .input=u::ReaderInputFormat::UTF8,
-                      });
+  auto uio = u8::open(io::memory("\xef"), u::ReaderConfig{
+                                            .strict = false,
+                                            .input = u::ReaderInputFormat::UTF8,
+                                          });
   std::string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
@@ -175,11 +185,11 @@ TEST(uio_u8, read_incomplete) {
 }
 
 TEST(uio_u16, read_incomplete_strict_be) {
-  auto uio = u16::open(io::memory("\x00"s),
-                       u::ReaderConfig{
-                         .strict=true,
-                         .input=u::ReaderInputFormat::UTF16_BE,
-                       });
+  auto uio =
+      u16::open(io::memory("\x00"s), u::ReaderConfig{
+                                       .strict = true,
+                                       .input = u::ReaderInputFormat::UTF16_BE,
+                                     });
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_FALSE(ret.has_value());
@@ -187,11 +197,11 @@ TEST(uio_u16, read_incomplete_strict_be) {
 }
 
 TEST(uio_u16, read_incomplete_be) {
-  auto uio = u16::open(io::memory("\x00"s),
-                       u::ReaderConfig{
-                         .strict=false,
-                         .input=u::ReaderInputFormat::UTF16_BE,
-                       });
+  auto uio =
+      u16::open(io::memory("\x00"s), u::ReaderConfig{
+                                       .strict = false,
+                                       .input = u::ReaderInputFormat::UTF16_BE,
+                                     });
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
@@ -200,11 +210,11 @@ TEST(uio_u16, read_incomplete_be) {
 }
 
 TEST(uio_u16, read_incomplete_strict_le) {
-  auto uio = u16::open(io::memory("$"),
-                       u::ReaderConfig{
-                         .strict=true,
-                         .input=u::ReaderInputFormat::UTF16_LE,
-                       });
+  auto uio =
+      u16::open(io::memory("$"), u::ReaderConfig{
+                                   .strict = true,
+                                   .input = u::ReaderInputFormat::UTF16_LE,
+                                 });
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_FALSE(ret.has_value());
@@ -212,11 +222,11 @@ TEST(uio_u16, read_incomplete_strict_le) {
 }
 
 TEST(uio_u16, read_incomplete_le) {
-  auto uio = u16::open(io::memory("$"),
-                       u::ReaderConfig{
-                         .strict=false,
-                         .input=u::ReaderInputFormat::UTF16_LE,
-                       });
+  auto uio =
+      u16::open(io::memory("$"), u::ReaderConfig{
+                                   .strict = false,
+                                   .input = u::ReaderInputFormat::UTF16_LE,
+                                 });
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
@@ -225,8 +235,9 @@ TEST(uio_u16, read_incomplete_le) {
 }
 
 TEST(uio_u8, max_too_small) {
-  auto uio = u8::open(io::memory("\xf0\x90\x8D\x85" "es"),
-                      u::ReaderConfig{.input=u::ReaderInputFormat::UTF8});
+  auto uio = u8::open(io::memory("\xf0\x90\x8D\x85"
+                                 "es"),
+                      u::ReaderConfig{.input = u::ReaderInputFormat::UTF8});
   std::string tmp;
   auto ret = uio->read(tmp.data(), 0);
   ASSERT_TRUE(ret.has_value());
@@ -238,8 +249,9 @@ TEST(uio_u8, max_too_small) {
 }
 
 TEST(uio_u16, max_too_small_be) {
-  auto uio = u16::open(io::memory("\xD8\x01\xDC\x37"),
-                      u::ReaderConfig{.input=u::ReaderInputFormat::UTF16_BE});
+  auto uio =
+      u16::open(io::memory("\xD8\x01\xDC\x37"),
+                u::ReaderConfig{.input = u::ReaderInputFormat::UTF16_BE});
   std::u16string tmp;
   auto ret = uio->read(tmp.data(), 0);
   ASSERT_TRUE(ret.has_value());
@@ -251,8 +263,9 @@ TEST(uio_u16, max_too_small_be) {
 }
 
 TEST(uio_u16, max_too_small_le) {
-  auto uio = u16::open(io::memory("\x01\xD8\x37\xDC"),
-                      u::ReaderConfig{.input=u::ReaderInputFormat::UTF16_LE});
+  auto uio =
+      u16::open(io::memory("\x01\xD8\x37\xDC"),
+                u::ReaderConfig{.input = u::ReaderInputFormat::UTF16_LE});
   std::u16string tmp;
   auto ret = uio->read(tmp.data(), 0);
   ASSERT_TRUE(ret.has_value());
@@ -264,8 +277,9 @@ TEST(uio_u16, max_too_small_le) {
 }
 
 TEST(uio_u8, partial) {
-  auto uio = u8::open(io::memory("\xf0\x90\x8D\x85" "es"),
-                      u::ReaderConfig{.input=u::ReaderInputFormat::UTF8});
+  auto uio = u8::open(io::memory("\xf0\x90\x8D\x85"
+                                 "es"),
+                      u::ReaderConfig{.input = u::ReaderInputFormat::UTF8});
   std::string tmp;
   auto ret = uio->repeat_read(tmp, 4);
   ASSERT_TRUE(ret.has_value());
@@ -279,8 +293,9 @@ TEST(uio_u8, partial) {
 }
 
 TEST(uio_u16, partial_be) {
-  auto uio = u16::open(io::memory("\x00\x24\xD8\x01\xDC\x37"s),
-                      u::ReaderConfig{.input=u::ReaderInputFormat::UTF16_BE});
+  auto uio =
+      u16::open(io::memory("\x00\x24\xD8\x01\xDC\x37"s),
+                u::ReaderConfig{.input = u::ReaderInputFormat::UTF16_BE});
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 1);
   ASSERT_TRUE(ret.has_value());
@@ -295,8 +310,9 @@ TEST(uio_u16, partial_be) {
 }
 
 TEST(uio_u16, partial_le) {
-  auto uio = u16::open(io::memory("\x24\x00\x01\xD8\x37\xDC"s),
-                      u::ReaderConfig{.input=u::ReaderInputFormat::UTF16_LE});
+  auto uio =
+      u16::open(io::memory("\x24\x00\x01\xD8\x37\xDC"s),
+                u::ReaderConfig{.input = u::ReaderInputFormat::UTF16_LE});
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 1);
   ASSERT_TRUE(ret.has_value());
@@ -312,10 +328,10 @@ TEST(uio_u16, partial_le) {
 
 TEST(uio_u16, invalid_be) {
   auto uio = u16::open(io::memory("\x00\x24\xd8\x01"s),
-                      u::ReaderConfig{
-                        .strict=true,
-                        .input=u::ReaderInputFormat::UTF16_BE,
-                      });
+                       u::ReaderConfig{
+                         .strict = true,
+                         .input = u::ReaderInputFormat::UTF16_BE,
+                       });
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
@@ -328,7 +344,7 @@ TEST(uio_u16, invalid_be) {
 
 TEST(uio_u16, invalid_detect_be) {
   auto uio = u16::open(io::memory("\x00\x24\xd8\x01"s),
-                      u::ReaderConfig{.strict=true});
+                       u::ReaderConfig{.strict = true});
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
@@ -341,10 +357,10 @@ TEST(uio_u16, invalid_detect_be) {
 
 TEST(uio_u16, invalid_replace_be) {
   auto uio = u16::open(io::memory("\x00\x24\xd8\x01"s),
-                      u::ReaderConfig{
-                        .strict=false,
-                        .input=u::ReaderInputFormat::UTF16_BE,
-                      });
+                       u::ReaderConfig{
+                         .strict = false,
+                         .input = u::ReaderInputFormat::UTF16_BE,
+                       });
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
@@ -355,10 +371,10 @@ TEST(uio_u16, invalid_replace_be) {
 
 TEST(uio_u16, invalid_le) {
   auto uio = u16::open(io::memory("\x24\x00\x01\xd8"s),
-                      u::ReaderConfig{
-                        .strict=true,
-                        .input=u::ReaderInputFormat::UTF16_LE,
-                      });
+                       u::ReaderConfig{
+                         .strict = true,
+                         .input = u::ReaderInputFormat::UTF16_LE,
+                       });
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
@@ -371,7 +387,7 @@ TEST(uio_u16, invalid_le) {
 
 TEST(uio_u16, invalid_detect_le) {
   auto uio = u16::open(io::memory("\x24\x00\x01\xd8"s),
-                      u::ReaderConfig{.strict=true});
+                       u::ReaderConfig{.strict = true});
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
@@ -384,10 +400,10 @@ TEST(uio_u16, invalid_detect_le) {
 
 TEST(uio_u16, invalid_replace_le) {
   auto uio = u16::open(io::memory("\x24\x00\x01\xd8"s),
-                      u::ReaderConfig{
-                        .strict=false,
-                        .input=u::ReaderInputFormat::UTF16_LE,
-                      });
+                       u::ReaderConfig{
+                         .strict = false,
+                         .input = u::ReaderInputFormat::UTF16_LE,
+                       });
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
@@ -397,31 +413,40 @@ TEST(uio_u16, invalid_replace_le) {
 }
 
 TEST(uio_u8, bom) {
-  auto uio = u8::open(io::memory("\xef\xbb\xbf\xf0\x90\x8D\x85" "es"),
-                      u::ReaderConfig{.input=u::ReaderInputFormat::UTF8});
+  auto uio = u8::open(io::memory("\xef\xbb\xbf\xf0\x90\x8D\x85"
+                                 "es"),
+                      u::ReaderConfig{.input = u::ReaderInputFormat::UTF8});
   std::string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
   EXPECT_EQ(6, ret.value());
-  EXPECT_EQ("\xf0\x90\x8D\x85" "es", tmp);
+  EXPECT_EQ(
+      "\xf0\x90\x8D\x85"
+      "es",
+      tmp);
 }
 
 TEST(uio_u8, bom_keep) {
-  auto uio = u8::open(io::memory("\xef\xbb\xbf\xf0\x90\x8D\x85" "es"),
+  auto uio = u8::open(io::memory("\xef\xbb\xbf\xf0\x90\x8D\x85"
+                                 "es"),
                       u::ReaderConfig{
-                        .input=u::ReaderInputFormat::UTF8,
-                        .skip_bom=false,
+                        .input = u::ReaderInputFormat::UTF8,
+                        .skip_bom = false,
                       });
   std::string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
   EXPECT_EQ(9, ret.value());
-  EXPECT_EQ("\xef\xbb\xbf\xf0\x90\x8D\x85" "es", tmp);
+  EXPECT_EQ(
+      "\xef\xbb\xbf\xf0\x90\x8D\x85"
+      "es",
+      tmp);
 }
 
 TEST(uio_u16, bom_be) {
-  auto uio = u16::open(io::memory("\xfe\xff\x00\x24\xD8\x01\xDC\x37"s),
-                      u::ReaderConfig{.input=u::ReaderInputFormat::UTF16_BE});
+  auto uio =
+      u16::open(io::memory("\xfe\xff\x00\x24\xD8\x01\xDC\x37"s),
+                u::ReaderConfig{.input = u::ReaderInputFormat::UTF16_BE});
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 5);
   ASSERT_TRUE(ret.has_value());
@@ -432,8 +457,9 @@ TEST(uio_u16, bom_be) {
 }
 
 TEST(uio_u16, bom_le) {
-  auto uio = u16::open(io::memory("\xff\xfe\x24\x00\x01\xD8\x37\xDC"s),
-                      u::ReaderConfig{.input=u::ReaderInputFormat::UTF16_LE});
+  auto uio =
+      u16::open(io::memory("\xff\xfe\x24\x00\x01\xD8\x37\xDC"s),
+                u::ReaderConfig{.input = u::ReaderInputFormat::UTF16_LE});
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 5);
   ASSERT_TRUE(ret.has_value());
@@ -445,10 +471,10 @@ TEST(uio_u16, bom_le) {
 
 TEST(uio_u16, bom_keep_be) {
   auto uio = u16::open(io::memory("\xfe\xff\x00\x24\xD8\x01\xDC\x37"s),
-                      u::ReaderConfig{
-                        .input=u::ReaderInputFormat::UTF16_BE,
-                        .skip_bom=false,
-                      });
+                       u::ReaderConfig{
+                         .input = u::ReaderInputFormat::UTF16_BE,
+                         .skip_bom = false,
+                       });
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 5);
   ASSERT_TRUE(ret.has_value());
@@ -461,10 +487,10 @@ TEST(uio_u16, bom_keep_be) {
 
 TEST(uio_u16, bom_keep_le) {
   auto uio = u16::open(io::memory("\xff\xfe\x24\x00\x01\xD8\x37\xDC"s),
-                      u::ReaderConfig{
-                        .input=u::ReaderInputFormat::UTF16_LE,
-                        .skip_bom=false,
-                      });
+                       u::ReaderConfig{
+                         .input = u::ReaderInputFormat::UTF16_LE,
+                         .skip_bom = false,
+                       });
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 5);
   ASSERT_TRUE(ret.has_value());
@@ -476,22 +502,31 @@ TEST(uio_u16, bom_keep_le) {
 }
 
 TEST(uio_u8, bom_detect) {
-  auto uio = u8::open(io::memory("\xef\xbb\xbf\xf0\x90\x8D\x85" "es"));
+  auto uio =
+      u8::open(io::memory("\xef\xbb\xbf\xf0\x90\x8D\x85"
+                          "es"));
   std::string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
   EXPECT_EQ(6, ret.value());
-  EXPECT_EQ("\xf0\x90\x8D\x85" "es", tmp);
+  EXPECT_EQ(
+      "\xf0\x90\x8D\x85"
+      "es",
+      tmp);
 }
 
 TEST(uio_u8, bom_keep_detect) {
-  auto uio = u8::open(io::memory("\xef\xbb\xbf\xf0\x90\x8D\x85" "es"),
-                      u::ReaderConfig{.skip_bom=false});
+  auto uio = u8::open(io::memory("\xef\xbb\xbf\xf0\x90\x8D\x85"
+                                 "es"),
+                      u::ReaderConfig{.skip_bom = false});
   std::string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
   EXPECT_EQ(9, ret.value());
-  EXPECT_EQ("\xef\xbb\xbf\xf0\x90\x8D\x85" "es", tmp);
+  EXPECT_EQ(
+      "\xef\xbb\xbf\xf0\x90\x8D\x85"
+      "es",
+      tmp);
 }
 
 TEST(uio_u16, bom_detect_be) {
@@ -518,7 +553,7 @@ TEST(uio_u16, bom_detect_le) {
 
 TEST(uio_u16, bom_keep_detect_be) {
   auto uio = u16::open(io::memory("\xfe\xff\x00\x24\xD8\x01\xDC\x37"s),
-                       u::ReaderConfig{.skip_bom=false});
+                       u::ReaderConfig{.skip_bom = false});
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 5);
   ASSERT_TRUE(ret.has_value());
@@ -531,7 +566,7 @@ TEST(uio_u16, bom_keep_detect_be) {
 
 TEST(uio_u16, bom_keep_detect_le) {
   auto uio = u16::open(io::memory("\xff\xfe\x24\x00\x01\xD8\x37\xDC"s),
-                       u::ReaderConfig{.skip_bom=false});
+                       u::ReaderConfig{.skip_bom = false});
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 5);
   ASSERT_TRUE(ret.has_value());
@@ -544,7 +579,7 @@ TEST(uio_u16, bom_keep_detect_le) {
 
 TEST(uio_u8, input_utf16_be) {
   auto uio = u8::open(io::memory("\x00\x24\xD8\x01\xDC\x37"s),
-                       u::ReaderConfig{.input=u::ReaderInputFormat::UTF16_BE});
+                      u::ReaderConfig{.input = u::ReaderInputFormat::UTF16_BE});
   std::string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
@@ -554,7 +589,7 @@ TEST(uio_u8, input_utf16_be) {
 
 TEST(uio_u8, input_utf16_le) {
   auto uio = u8::open(io::memory("\x24\x00\x01\xD8\x37\xDC"s),
-                       u::ReaderConfig{.input=u::ReaderInputFormat::UTF16_LE});
+                      u::ReaderConfig{.input = u::ReaderInputFormat::UTF16_LE});
   std::string tmp;
   auto ret = uio->repeat_read(tmp, 10);
   ASSERT_TRUE(ret.has_value());
@@ -563,8 +598,9 @@ TEST(uio_u8, input_utf16_le) {
 }
 
 TEST(uio_u16, input_utf8) {
-  auto uio = u16::open(io::memory("\xf0\x90\x8D\x85" "es"),
-                       u::ReaderConfig{.input=u::ReaderInputFormat::UTF8});
+  auto uio = u16::open(io::memory("\xf0\x90\x8D\x85"
+                                  "es"),
+                       u::ReaderConfig{.input = u::ReaderInputFormat::UTF8});
   std::u16string tmp;
   auto ret = uio->repeat_read(tmp, 5);
   ASSERT_TRUE(ret.has_value());
@@ -576,8 +612,9 @@ TEST(uio_u16, input_utf8) {
 }
 
 TEST(uio_u8, skip) {
-  auto uio = u8::open(io::memory("\xf0\x90\x8D\x85" "es"),
-                      u::ReaderConfig{.input=u::ReaderInputFormat::UTF8});
+  auto uio = u8::open(io::memory("\xf0\x90\x8D\x85"
+                                 "es"),
+                      u::ReaderConfig{.input = u::ReaderInputFormat::UTF8});
   std::string tmp;
   auto ret = uio->repeat_skip(3);
   ASSERT_FALSE(ret.has_value());
@@ -592,8 +629,9 @@ TEST(uio_u8, skip) {
 }
 
 TEST(uio_u16, skip_be) {
-  auto uio = u16::open(io::memory("\x00\x24\xD8\x01\xDC\x37"s),
-                      u::ReaderConfig{.input=u::ReaderInputFormat::UTF16_BE});
+  auto uio =
+      u16::open(io::memory("\x00\x24\xD8\x01\xDC\x37"s),
+                u::ReaderConfig{.input = u::ReaderInputFormat::UTF16_BE});
   std::u16string tmp;
   auto ret = uio->repeat_skip(4);  // Note that this is in bytes
   ASSERT_TRUE(ret.has_value());
@@ -606,8 +644,9 @@ TEST(uio_u16, skip_be) {
 }
 
 TEST(uio_u16, skip_le) {
-  auto uio = u16::open(io::memory("\x24\x00\x01\xD8\x37\xDC"s),
-                      u::ReaderConfig{.input=u::ReaderInputFormat::UTF16_LE});
+  auto uio =
+      u16::open(io::memory("\x24\x00\x01\xD8\x37\xDC"s),
+                u::ReaderConfig{.input = u::ReaderInputFormat::UTF16_LE});
   std::u16string tmp;
   auto ret = uio->repeat_skip(4);  // Note that this is in bytes
   ASSERT_TRUE(ret.has_value());