Apply cmake-format

.cmake-format.yaml

@@ -0,0 +1,4 @@
+format:
+  separate_ctrl_name_with_space: true
+markup:
+  enable_markup: false

CMakeLists.txt

@@ -6,8 +6,8 @@ if (${CMAKE_VERSION} VERSION_LESS 3.12)
   cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
 endif ()
 
-# Determine if fmt is built as a subproject (using add_subdirectory)
+# Determine if fmt is built as a subproject (using add_subdirectory) or if it is
-# or if it is the master project.
+# the master project.
 if (NOT DEFINED FMT_MASTER_PROJECT)
   set(FMT_MASTER_PROJECT OFF)
   # Checking project name is more reliable than checking source directories.
@@ -23,7 +23,9 @@ function(join result_var)
   foreach (arg ${ARGN})
     set(result "${result}${arg}")
   endforeach ()
-  set(${result_var} "${result}" PARENT_SCOPE)
+  set(${result_var}
+      "${result}"
+      PARENT_SCOPE)
 endfunction ()
 
 # Sets a cache variable with a docstring joined from multiple arguments:
@@ -31,14 +33,17 @@ endfunction()
 # This allows splitting a long docstring for readability.
 function (set_verbose variable value _cache type)
   join(doc ${ARGN})
-  set(${variable} ${value} CACHE ${type} ${doc})
+  set(${variable}
+      ${value}
+      CACHE ${type} ${doc})
 endfunction ()
 
 # Set the default CMAKE_BUILD_TYPE to Release.
 # This should be done before the project command since the latter can set
 # CMAKE_BUILD_TYPE itself (it does so for nmake).
 if (FMT_MASTER_PROJECT AND NOT CMAKE_BUILD_TYPE)
-  set_verbose(CMAKE_BUILD_TYPE Release CACHE STRING
+  set_verbose(
+    CMAKE_BUILD_TYPE Release CACHE STRING
     "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or "
     "CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
 endif ()
@@ -48,16 +53,16 @@ project(FMT CXX)
 # Determine support for the C++ module scanning.
 # Requires C++20, CMake >= 3.28 and (Ninja >= 1.11 OR Visual Studio >= 17.4).
 set(FMT_USE_CMAKE_MODULES FALSE)
-if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.28 AND
+if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.28 AND CMAKE_CXX_STANDARD
-    CMAKE_CXX_STANDARD GREATER_EQUAL 20)
+                                                 GREATER_EQUAL 20)
   if (CMAKE_GENERATOR STREQUAL "Ninja")
     execute_process(COMMAND "${CMAKE_MAKE_PROGRAM}" "--version"
                     OUTPUT_VARIABLE NINJA_VERSION)
     if (NINJA_VERSION VERSION_GREATER_EQUAL 1.11)
       set(FMT_USE_CMAKE_MODULES TRUE)
     endif ()
-  elseif (CMAKE_GENERATOR MATCHES "^Visual Studio" AND
+  elseif (CMAKE_GENERATOR MATCHES "^Visual Studio" AND MSVC_VERSION
-          MSVC_VERSION GREATER_EQUAL 1934)
+                                                       GREATER_EQUAL 1934)
     set(FMT_USE_CMAKE_MODULES TRUE)
   endif ()
 endif ()
@@ -82,11 +87,14 @@ endif ()
 
 include(GNUInstallDirs) # CMAKE_INSTALL_INCLUDEDIR
 
-set_verbose(FMT_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE STRING
+set_verbose(
+  FMT_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE STRING
   "Installation directory for include files, a relative path that "
   "will be joined with ${CMAKE_INSTALL_PREFIX} or an absolute path.")
 
-set(FMT_DEBUG_POSTFIX d CACHE STRING "Debug library postfix.")
+set(FMT_DEBUG_POSTFIX
+    d
+    CACHE STRING "Debug library postfix.")
 
 # Get version from base.h.
 file(READ include/fmt/base.h base_h)
@@ -115,41 +123,60 @@ include(JoinPaths)
 if (FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_CXX_VISIBILITY_PRESET)
   set_verbose(CMAKE_CXX_VISIBILITY_PRESET hidden CACHE STRING
               "Preset for the export of private symbols.")
-  set_property(CACHE CMAKE_CXX_VISIBILITY_PRESET PROPERTY STRINGS
+  set_property(CACHE CMAKE_CXX_VISIBILITY_PRESET PROPERTY STRINGS hidden
-               hidden default)
+                                                          default)
 endif ()
 
 if (FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_VISIBILITY_INLINES_HIDDEN)
-  set_verbose(CMAKE_VISIBILITY_INLINES_HIDDEN ON CACHE BOOL
+  set_verbose(
-              "Whether to add a compile flag to hide symbols of inline "
+    CMAKE_VISIBILITY_INLINES_HIDDEN ON CACHE BOOL
-              "functions.")
+    "Whether to add a compile flag to hide symbols of inline " "functions.")
 endif ()
 
 if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-  set(PEDANTIC_COMPILE_FLAGS -pedantic-errors -Wall -Wextra -pedantic
+  set(PEDANTIC_COMPILE_FLAGS
-      -Wold-style-cast -Wundef
+      -pedantic-errors
-      -Wredundant-decls -Wwrite-strings -Wpointer-arith
+      -Wall
-      -Wcast-qual -Wformat=2 -Wmissing-include-dirs
+      -Wextra
+      -pedantic
+      -Wold-style-cast
+      -Wundef
+      -Wredundant-decls
+      -Wwrite-strings
+      -Wpointer-arith
+      -Wcast-qual
+      -Wformat=2
+      -Wmissing-include-dirs
       -Wcast-align
-      -Wctor-dtor-privacy -Wdisabled-optimization
+      -Wctor-dtor-privacy
-      -Winvalid-pch -Woverloaded-virtual
+      -Wdisabled-optimization
-      -Wconversion -Wundef
+      -Winvalid-pch
-      -Wno-ctor-dtor-privacy -Wno-format-nonliteral)
+      -Woverloaded-virtual
+      -Wconversion
+      -Wundef
+      -Wno-ctor-dtor-privacy
+      -Wno-format-nonliteral)
   if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6)
-      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS}
+    set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wno-dangling-else
-         -Wno-dangling-else -Wno-unused-local-typedefs)
+                               -Wno-unused-local-typedefs)
   endif ()
   if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
-      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wdouble-promotion
+    set(PEDANTIC_COMPILE_FLAGS
-          -Wtrampolines -Wzero-as-null-pointer-constant -Wuseless-cast
+        ${PEDANTIC_COMPILE_FLAGS}
-          -Wvector-operation-performance -Wsized-deallocation -Wshadow)
+        -Wdouble-promotion
+        -Wtrampolines
+        -Wzero-as-null-pointer-constant
+        -Wuseless-cast
+        -Wvector-operation-performance
+        -Wsized-deallocation
+        -Wshadow)
   endif ()
   if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.0)
     set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wshift-overflow=2
                                -Wduplicated-cond)
-      # Workaround for GCC regression
+    # Workaround for GCC 12-15 regression:
-      # [12/13/14/15 regression] New (since gcc 12) false positive null-dereference in vector.resize
+    # a false positive null-dereference in vector.resize
-      # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108860
+    # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108860.
     if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0)
       set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wnull-dereference)
     endif ()
@@ -158,8 +185,15 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
 endif ()
 
 if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-  set(PEDANTIC_COMPILE_FLAGS -Wall -Wextra -pedantic -Wconversion -Wundef
+  set(PEDANTIC_COMPILE_FLAGS
-      -Wdeprecated -Wweak-vtables -Wshadow
+      -Wall
+      -Wextra
+      -pedantic
+      -Wconversion
+      -Wundef
+      -Wdeprecated
+      -Wweak-vtables
+      -Wshadow
       -Wno-gnu-zero-variadic-macro-arguments)
   check_cxx_compiler_flag(-Wzero-as-null-pointer-constant HAS_NULLPTR_WARNING)
   if (HAS_NULLPTR_WARNING)
@@ -187,8 +221,7 @@ if (FMT_MASTER_PROJECT AND CMAKE_GENERATOR MATCHES "Visual Studio")
   join(netfxpath
        "C:\\Program Files\\Reference Assemblies\\Microsoft\\Framework\\"
        ".NETFramework\\v4.0")
-  file(WRITE run-msbuild.bat "
+  file(WRITE run-msbuild.bat "${MSBUILD_SETUP}
-    ${MSBUILD_SETUP}
     ${CMAKE_MAKE_PROGRAM} -p:FrameworkPathOverride=\"${netfxpath}\" %*")
 endif ()
 
@@ -197,8 +230,8 @@ endif ()
 function (setup_target target kind)
   add_library(fmt::${target} ALIAS ${target})
 
-  target_include_directories(${target}
+  target_include_directories(
-    ${FMT_SYSTEM_HEADERS_ATTRIBUTE} BEFORE ${kind}
+    ${target} ${FMT_SYSTEM_HEADERS_ATTRIBUTE} BEFORE ${kind}
     $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
     $<INSTALL_INTERFACE:${FMT_INC_DIR}>)
 
@@ -206,21 +239,37 @@ function(setup_target target kind)
     # Unicode is always supported on compilers other than MSVC.
   elseif (FMT_UNICODE)
     # Unicode support requires compiling with /utf-8.
-    target_compile_options(${target} ${kind}
+    target_compile_options(
+      ${target} ${kind}
       $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/utf-8>)
   else ()
     target_compile_definitions(${target} ${kind} FMT_UNICODE=0)
   endif ()
 
-  set_target_properties(${target} PROPERTIES
+  set_target_properties(
-    VERSION ${FMT_VERSION}
+    ${target}
+    PROPERTIES VERSION ${FMT_VERSION}
                SOVERSION ${CPACK_PACKAGE_VERSION_MAJOR}
                DEBUG_POSTFIX "${FMT_DEBUG_POSTFIX}")
 endfunction ()
 
 set(FMT_HEADERS)
-foreach (header args.h base.h chrono.h color.h compile.h core.h format.h
+foreach (
-                format-inl.h os.h ostream.h printf.h ranges.h std.h xchar.h)
+  header
+  args.h
+  base.h
+  chrono.h
+  color.h
+  compile.h
+  core.h
+  format.h
+  format-inl.h
+  os.h
+  ostream.h
+  printf.h
+  ranges.h
+  std.h
+  xchar.h)
   set(FMT_HEADERS ${FMT_HEADERS} include/fmt/${header})
 endforeach ()
 
@@ -256,7 +305,10 @@ if (CMAKE_BUILD_TYPE STREQUAL "Debug")
 endif ()
 
 if (BUILD_SHARED_LIBS)
-  target_compile_definitions(fmt PRIVATE FMT_LIB_EXPORT INTERFACE FMT_SHARED)
+  target_compile_definitions(
+    fmt
+    PRIVATE FMT_LIB_EXPORT
+    INTERFACE FMT_SHARED)
 endif ()
 if (FMT_SAFE_DURATION_CAST)
   target_compile_definitions(fmt PUBLIC FMT_SAFE_DURATION_CAST)
@@ -282,7 +334,8 @@ function(add_module_library name)
     if (NOT CMAKE_GENERATOR STREQUAL "Ninja")
       set(BMI_DIR "${CMAKE_CURRENT_BINARY_DIR}")
       file(TO_NATIVE_PATH "${BMI_DIR}/${name}.ifc" BMI)
-      target_compile_options(${name}
+      target_compile_options(
+        ${name}
         PRIVATE /interface /ifcOutput ${BMI}
         INTERFACE /reference fmt=${BMI})
       set_target_properties(${name} PROPERTIES ADDITIONAL_CLEAN_FILES ${BMI})
@@ -291,8 +344,8 @@ function(add_module_library name)
   endif ()
 
   if (${AML_USE_CMAKE_MODULES})
-    target_sources(${name} PUBLIC FILE_SET fmt TYPE CXX_MODULES
+    target_sources(${name} PUBLIC FILE_SET fmt TYPE CXX_MODULES FILES
-                   FILES ${sources})
+                                  ${sources})
     return()
   endif ()
 
@@ -318,9 +371,9 @@ function(add_module_library name)
       set(pcms ${pcms} ${CMAKE_CURRENT_BINARY_DIR}/${pcm})
       add_custom_command(
         OUTPUT ${pcm}
-        COMMAND ${CMAKE_CXX_COMPILER}
+        COMMAND
-                -std=c++${std} -x c++-module --precompile -c
+          ${CMAKE_CXX_COMPILER} -std=c++${std} -x c++-module --precompile -c -o
-                -o ${pcm} ${CMAKE_CURRENT_SOURCE_DIR}/${src}
+          ${pcm} ${CMAKE_CURRENT_SOURCE_DIR}/${src}
           "-I$<JOIN:$<TARGET_PROPERTY:${name},INCLUDE_DIRECTORIES>,;-I>"
         # Required by the -I generator expression above.
         COMMAND_EXPAND_LISTS
@@ -345,8 +398,8 @@ function(add_module_library name)
 endfunction ()
 
 if (FMT_MODULE)
-  add_module_library(fmt-module src/fmt.cc
+  add_module_library(fmt-module src/fmt.cc USE_CMAKE_MODULES
-    USE_CMAKE_MODULES ${FMT_USE_CMAKE_MODULES})
+                     ${FMT_USE_CMAKE_MODULES})
   setup_target(fmt-module PUBLIC)
 endif ()
 
@@ -367,7 +420,11 @@ add_library(fmt::fmt-c ALIAS fmt-c)
 # Install targets.
 if (FMT_INSTALL)
   include(CMakePackageConfigHelpers)
-  set_verbose(FMT_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/fmt CACHE STRING
+  set_verbose(
+    FMT_CMAKE_DIR
+    ${CMAKE_INSTALL_LIBDIR}/cmake/fmt
+    CACHE
+    STRING
     "Installation directory for cmake files, a relative path that "
     "will be joined with ${CMAKE_INSTALL_PREFIX} or an absolute "
     "path.")
@@ -376,11 +433,16 @@ if (FMT_INSTALL)
   set(pkgconfig ${PROJECT_BINARY_DIR}/fmt.pc)
   set(targets_export_name fmt-targets)
 
-  set_verbose(FMT_LIB_DIR ${CMAKE_INSTALL_LIBDIR} CACHE STRING
+  set_verbose(
+    FMT_LIB_DIR ${CMAKE_INSTALL_LIBDIR} CACHE STRING
     "Installation directory for libraries, a relative path that "
     "will be joined to ${CMAKE_INSTALL_PREFIX} or an absolute path.")
 
-  set_verbose(FMT_PKGCONFIG_DIR ${CMAKE_INSTALL_LIBDIR}/pkgconfig CACHE STRING
+  set_verbose(
+    FMT_PKGCONFIG_DIR
+    ${CMAKE_INSTALL_LIBDIR}/pkgconfig
+    CACHE
+    STRING
     "Installation directory for pkgconfig (.pc) files, a relative "
     "path that will be joined with ${CMAKE_INSTALL_PREFIX} or an "
     "absolute path.")
@@ -394,13 +456,10 @@ if (FMT_INSTALL)
   join_paths(libdir_for_pc_file "\${exec_prefix}" "${FMT_LIB_DIR}")
   join_paths(includedir_for_pc_file "\${prefix}" "${FMT_INC_DIR}")
 
-  configure_file(
+  configure_file("${PROJECT_SOURCE_DIR}/support/cmake/fmt.pc.in" "${pkgconfig}"
-    "${PROJECT_SOURCE_DIR}/support/cmake/fmt.pc.in"
-    "${pkgconfig}"
                  @ONLY)
   configure_package_config_file(
-    ${PROJECT_SOURCE_DIR}/support/cmake/fmt-config.cmake.in
+    ${PROJECT_SOURCE_DIR}/support/cmake/fmt-config.cmake.in ${project_config}
-    ${project_config}
     INSTALL_DESTINATION ${FMT_CMAKE_DIR})
 
   set(INSTALL_TARGETS fmt fmt-header-only fmt-c)
@@ -413,35 +472,41 @@ if (FMT_INSTALL)
   endif ()
 
   # Install the library and headers.
-  install(TARGETS ${INSTALL_TARGETS}
+  install(
+    TARGETS ${INSTALL_TARGETS}
     COMPONENT fmt_core
     EXPORT ${targets_export_name}
     LIBRARY DESTINATION ${FMT_LIB_DIR}
     ARCHIVE DESTINATION ${FMT_LIB_DIR}
     PUBLIC_HEADER DESTINATION ${FMT_INC_DIR}/fmt
-          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} ${INSTALL_FILE_SET})
-          ${INSTALL_FILE_SET})
 
   # Use a namespace because CMake provides better diagnostics for namespaced
   # imported targets.
-  export(TARGETS ${INSTALL_TARGETS} NAMESPACE fmt::
+  export(
+    TARGETS ${INSTALL_TARGETS}
+    NAMESPACE fmt::
     FILE ${PROJECT_BINARY_DIR}/${targets_export_name}.cmake)
 
   # Install version, config and target files.
-  install(FILES ${project_config} ${version_config}
+  install(
+    FILES ${project_config} ${version_config}
     DESTINATION ${FMT_CMAKE_DIR}
     COMPONENT fmt_core)
-  install(EXPORT ${targets_export_name} DESTINATION ${FMT_CMAKE_DIR}
+  install(
+    EXPORT ${targets_export_name}
+    DESTINATION ${FMT_CMAKE_DIR}
     NAMESPACE fmt::
     COMPONENT fmt_core)
 
-  install(FILES "${pkgconfig}" DESTINATION "${FMT_PKGCONFIG_DIR}"
+  install(
+    FILES "${pkgconfig}"
+    DESTINATION "${FMT_PKGCONFIG_DIR}"
     COMPONENT fmt_core)
 endif ()
 
 function (add_doc_target)
-  find_program(DOXYGEN doxygen
+  find_program(DOXYGEN doxygen PATHS "$ENV{ProgramFiles}/doxygen/bin"
-    PATHS "$ENV{ProgramFiles}/doxygen/bin"
                                      "$ENV{ProgramFiles\(x86\)}/doxygen/bin")
   if (NOT DOXYGEN)
     message(STATUS "Target 'doc' disabled because doxygen not found")
@@ -462,18 +527,19 @@ function(add_doc_target)
   add_custom_target(
     doc
     COMMAND
-      ${CMAKE_COMMAND}
+      ${CMAKE_COMMAND} -E env
-        -E env PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}/support/python
+      PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}/support/python ${MKDOCS} build -f
-        ${MKDOCS} build -f ${CMAKE_CURRENT_SOURCE_DIR}/support/mkdocs.yml
+      ${CMAKE_CURRENT_SOURCE_DIR}/support/mkdocs.yml
       # MkDocs requires the site dir to be outside of the doc dir.
-                        --site-dir ${CMAKE_CURRENT_BINARY_DIR}/doc-html
+      --site-dir ${CMAKE_CURRENT_BINARY_DIR}/doc-html --no-directory-urls
-                        --no-directory-urls
     SOURCES ${sources})
 
   include(GNUInstallDirs)
-  install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/doc-html/
+  install(
+    DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/doc-html/
     DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/doc/fmt
-          COMPONENT fmt_doc OPTIONAL)
+    COMPONENT fmt_doc
+    OPTIONAL)
 endfunction ()
 
 if (FMT_DOC)

support/cmake/FindSetEnv.cmake

@@ -1,7 +1,11 @@
 # A CMake script to find SetEnv.cmd.
 
-find_program(WINSDK_SETENV NAMES SetEnv.cmd
+find_program(
-  PATHS "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows;CurrentInstallFolder]/bin")
+  WINSDK_SETENV
+  NAMES SetEnv.cmd
+  PATHS
+    "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows;CurrentInstallFolder]/bin"
+)
 if (WINSDK_SETENV AND PRINT_PATH)
   execute_process(COMMAND ${CMAKE_COMMAND} -E echo "${WINSDK_SETENV}")
 endif ()

support/cmake/JoinPaths.cmake

@@ -1,16 +1,16 @@
-# This module provides function for joining paths
+# This module provides function for joining paths known from from most languages
-# known from from most languages
 #
 # Original license:
 # SPDX-License-Identifier: (MIT OR CC0-1.0)
-# Explicit permission given to distribute this module under
+# Explicit permission given to distribute this module under the terms of the
-# the terms of the project as described in /LICENSE.rst.
+# project as described in /LICENSE.md.
 # Copyright 2020 Jan Tojnar
 # https://github.com/jtojnar/cmake-snips
 #
 # Modelled after Python’s os.path.join
 # https://docs.python.org/3.7/library/os.path.html#os.path.join
 # Windows not supported
+
 function (join_paths joined_path first_path_segment)
   set(temp_path "${first_path_segment}")
   foreach (current_segment IN LISTS ARGN)
@@ -22,5 +22,7 @@ function(join_paths joined_path first_path_segment)
       endif ()
     endif ()
   endforeach ()
-    set(${joined_path} "${temp_path}" PARENT_SCOPE)
+  set(${joined_path}
+      "${temp_path}"
+      PARENT_SCOPE)
 endfunction ()

test/CMakeLists.txt

@@ -2,8 +2,8 @@ add_subdirectory(gtest)
 
 set(TEST_MAIN_SRC test-main.cc gtest-extra.cc gtest-extra.h util.cc)
 add_library(test-main STATIC ${TEST_MAIN_SRC})
-target_include_directories(test-main PUBLIC
+target_include_directories(
-  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
+  test-main PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
 target_link_libraries(test-main gtest fmt)
 
 # Adds a test.
@@ -60,8 +60,8 @@ add_fmt_test(ranges-test ranges-odr-test.cc)
 add_fmt_test(no-builtin-types-test HEADER_ONLY)
 add_fmt_test(scan-test HEADER_ONLY)
 add_fmt_test(std-test)
-try_compile(compile_result_unused
+try_compile(
-            ${CMAKE_CURRENT_BINARY_DIR}
+  compile_result_unused ${CMAKE_CURRENT_BINARY_DIR}
   SOURCES ${CMAKE_CURRENT_LIST_DIR}/detect-stdfs.cc
   OUTPUT_VARIABLE RAWOUTPUT)
 string(REGEX REPLACE ".*libfound \"([^\"]*)\".*" "\\1" STDLIBFS "${RAWOUTPUT}")
@@ -74,8 +74,8 @@ if (MSVC)
 endif ()
 add_fmt_test(xchar-test)
 add_fmt_test(enforce-checks-test)
-target_compile_definitions(enforce-checks-test PRIVATE
+target_compile_definitions(enforce-checks-test
-                           -DFMT_ENFORCE_COMPILE_STRING)
+                           PRIVATE -DFMT_ENFORCE_COMPILE_STRING)
 
 add_executable(perf-sanity perf-sanity.cc)
 target_link_libraries(perf-sanity fmt::fmt)
@@ -98,10 +98,10 @@ if (NOT DEFINED MSVC_STATIC_RUNTIME AND MSVC)
 endif ()
 
 if (NOT MSVC_STATIC_RUNTIME)
-  add_executable(posix-mock-test
+  add_executable(posix-mock-test posix-mock-test.cc ../src/format.cc
-    posix-mock-test.cc ../src/format.cc ${TEST_MAIN_SRC})
+                                 ${TEST_MAIN_SRC})
-  target_include_directories(
+  target_include_directories(posix-mock-test
-    posix-mock-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
+                             PRIVATE ${PROJECT_SOURCE_DIR}/include)
   target_link_libraries(posix-mock-test gtest)
   if (FMT_PEDANTIC)
     target_compile_options(posix-mock-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
@@ -123,34 +123,38 @@ if (FMT_PEDANTIC)
   endif ()
   if (HAVE_FNO_EXCEPTIONS_FLAG)
     add_library(noexception-test ../src/format.cc noexception-test.cc)
-    target_include_directories(
+    target_include_directories(noexception-test
-      noexception-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
+                               PRIVATE ${PROJECT_SOURCE_DIR}/include)
     target_compile_options(noexception-test PRIVATE -fno-exceptions)
     target_compile_options(noexception-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
   endif ()
 
   # Test that the library compiles without locale.
   add_library(nolocale-test ../src/format.cc)
-  target_include_directories(
+  target_include_directories(nolocale-test
-    nolocale-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
+                             PRIVATE ${PROJECT_SOURCE_DIR}/include)
-  target_compile_definitions(
+  target_compile_definitions(nolocale-test
-    nolocale-test PRIVATE FMT_STATIC_THOUSANDS_SEPARATOR=1)
+                             PRIVATE FMT_STATIC_THOUSANDS_SEPARATOR=1)
 endif ()
 
 # These tests are disabled on Windows because they take too long.
-# They are disabled on GCC < 4.9 because it can not parse UDLs without
+# They are disabled on GCC < 4.9 because it can't parse UDLs without a space
-# a space after `operator""` but that is an incorrect syntax for any more
+# after operator"" but that is an incorrect syntax for any more modern compiler.
-# modern compiler.
+if (FMT_PEDANTIC
-if (FMT_PEDANTIC AND NOT WIN32 AND NOT (
+    AND NOT WIN32
-    CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND
+    AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND CMAKE_CXX_COMPILER_VERSION
-    CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9))
+                                                     VERSION_LESS 4.9))
   # Test if incorrect API usages produce compilation error.
-  add_test(compile-error-test ${CMAKE_CTEST_COMMAND}
+  add_test(
+    compile-error-test
+    ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMAKE_CURRENT_SOURCE_DIR}/compile-error-test"
     "${CMAKE_CURRENT_BINARY_DIR}/compile-error-test"
-    --build-generator ${CMAKE_GENERATOR}
+    --build-generator
-    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+    ${CMAKE_GENERATOR}
+    --build-makeprogram
+    ${CMAKE_MAKE_PROGRAM}
     --build-options
     "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
     "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}"
@@ -159,13 +163,18 @@ if (FMT_PEDANTIC AND NOT WIN32 AND NOT (
     "-DFMT_DIR=${CMAKE_SOURCE_DIR}")
 
   # Test if the targets are found from the build directory.
-  add_test(find-package-test ${CMAKE_CTEST_COMMAND}
+  add_test(
-    -C ${CMAKE_BUILD_TYPE}
+    find-package-test
+    ${CMAKE_CTEST_COMMAND}
+    -C
+    ${CMAKE_BUILD_TYPE}
     --build-and-test
     "${CMAKE_CURRENT_SOURCE_DIR}/find-package-test"
     "${CMAKE_CURRENT_BINARY_DIR}/find-package-test"
-    --build-generator ${CMAKE_GENERATOR}
+    --build-generator
-    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+    ${CMAKE_GENERATOR}
+    --build-makeprogram
+    ${CMAKE_MAKE_PROGRAM}
     --build-options
     "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
     "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}"
@@ -175,13 +184,18 @@ if (FMT_PEDANTIC AND NOT WIN32 AND NOT (
     "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
 
   # Test if the targets are found when add_subdirectory is used.
-  add_test(add-subdirectory-test ${CMAKE_CTEST_COMMAND}
+  add_test(
-    -C ${CMAKE_BUILD_TYPE}
+    add-subdirectory-test
+    ${CMAKE_CTEST_COMMAND}
+    -C
+    ${CMAKE_BUILD_TYPE}
     --build-and-test
     "${CMAKE_CURRENT_SOURCE_DIR}/add-subdirectory-test"
     "${CMAKE_CURRENT_BINARY_DIR}/add-subdirectory-test"
-    --build-generator ${CMAKE_GENERATOR}
+    --build-generator
-    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+    ${CMAKE_GENERATOR}
+    --build-makeprogram
+    ${CMAKE_MAKE_PROGRAM}
     --build-options
     "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
     "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
@@ -191,13 +205,18 @@ endif ()
 
 # This test is disabled on Windows because it is POSIX-specific.
 if (FMT_PEDANTIC AND NOT WIN32)
-  add_test(static-export-test ${CMAKE_CTEST_COMMAND}
+  add_test(
-    -C ${CMAKE_BUILD_TYPE}
+    static-export-test
+    ${CMAKE_CTEST_COMMAND}
+    -C
+    ${CMAKE_BUILD_TYPE}
     --build-and-test
     "${CMAKE_CURRENT_SOURCE_DIR}/static-export-test"
     "${CMAKE_CURRENT_BINARY_DIR}/static-export-test"
-    --build-generator ${CMAKE_GENERATOR}
+    --build-generator
-    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+    ${CMAKE_GENERATOR}
+    --build-makeprogram
+    ${CMAKE_MAKE_PROGRAM}
     --build-options
     "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
     "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"

test/compile-error-test/CMakeLists.txt

@@ -3,7 +3,8 @@
 cmake_minimum_required(VERSION 3.8...3.25)
 project(compile-error-test CXX)
 
-set(fmt_headers "
+set(fmt_headers
+    "
   #include <fmt/format.h>
   #include <fmt/xchar.h>
   #include <fmt/ostream.h>
@@ -13,7 +14,7 @@ set(fmt_headers "
 set(error_test_names "")
 set(non_error_test_content "")
 
-# For error tests (we expect them to produce compilation error):
+# For error tests (we expect them to produce compilation error)
 #  * adds a name of test into `error_test_names` list
 #  * generates a single source file (with the same name) for each test
 # For non-error tests (we expect them to compile successfully):
@@ -23,7 +24,9 @@ function (expect_compile name code_fragment)
   string(MAKE_C_IDENTIFIER "${name}" test_name)
 
   if (EXPECT_COMPILE_ERROR)
-    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/test/${test_name}.cc" "
+    file(
+      WRITE "${CMAKE_CURRENT_BINARY_DIR}/test/${test_name}.cc"
+      "
       ${fmt_headers}
       void ${test_name}() {
         ${code_fragment}
@@ -31,13 +34,17 @@ function (expect_compile name code_fragment)
       ")
     set(error_test_names_copy "${error_test_names}")
     list(APPEND error_test_names_copy "${test_name}")
-    set(error_test_names "${error_test_names_copy}" PARENT_SCOPE)
+    set(error_test_names
+        "${error_test_names_copy}"
+        PARENT_SCOPE)
   else ()
-    set(non_error_test_content "
+    set(non_error_test_content
+        "
         ${non_error_test_content}
         void ${test_name}() {
           ${code_fragment}
-      }" PARENT_SCOPE)
+        }"
+        PARENT_SCOPE)
   endif ()
 endfunction ()
 
@@ -46,24 +53,30 @@ endfunction ()
 function (run_tests)
   set(cmake_targets "")
   foreach (test_name IN LISTS error_test_names)
-    set(cmake_targets "
+    set(cmake_targets
+        "
         ${cmake_targets}
         add_library(test-${test_name} ${test_name}.cc)
         target_link_libraries(test-${test_name} PRIVATE fmt::fmt)
         ")
   endforeach ()
 
-  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/test/non_error_test.cc" "
+  file(
+    WRITE "${CMAKE_CURRENT_BINARY_DIR}/test/non_error_test.cc"
+    "
     ${fmt_headers}
     ${non_error_test_content}
     ")
-  set(cmake_targets "
+  set(cmake_targets
+      "
       ${cmake_targets}
       add_library(non-error-test non_error_test.cc)
       target_link_libraries(non-error-test PRIVATE fmt::fmt)
       ")
 
-  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/test/CMakeLists.txt" "
+  file(
+    WRITE "${CMAKE_CURRENT_BINARY_DIR}/test/CMakeLists.txt"
+    "
     cmake_minimum_required(VERSION 3.8...3.25)
     project(tests CXX)
     add_subdirectory(${FMT_DIR} fmt)
@@ -74,13 +87,11 @@ function (run_tests)
   file(MAKE_DIRECTORY "${build_directory}")
   execute_process(
     COMMAND
-      "${CMAKE_COMMAND}"
+      "${CMAKE_COMMAND}" "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
-      "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
       "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}"
       "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
       "-DCMAKE_GENERATOR=${CMAKE_GENERATOR}"
-      "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
+      "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}" "-DFMT_DIR=${FMT_DIR}"
-      "-DFMT_DIR=${FMT_DIR}"
       "${CMAKE_CURRENT_BINARY_DIR}/test"
     WORKING_DIRECTORY "${build_directory}"
     RESULT_VARIABLE result_var
@@ -92,26 +103,28 @@ function (run_tests)
 
   foreach (test_name IN LISTS error_test_names)
     execute_process(
-      COMMAND
+      COMMAND "${CMAKE_COMMAND}" --build "${build_directory}" --target
-        "${CMAKE_COMMAND}" --build "${build_directory}" --target "test-${test_name}"
+              "test-${test_name}"
       WORKING_DIRECTORY "${build_directory}"
       RESULT_VARIABLE result_var
       OUTPUT_VARIABLE output_var
       ERROR_QUIET)
     if (result_var EQUAL 0)
-      message(SEND_ERROR "No compile error for \"${test_name}\":\n${output_var}")
+      message(
+        SEND_ERROR "No compile error for \"${test_name}\":\n${output_var}")
     endif ()
   endforeach ()
 
   execute_process(
-    COMMAND
+    COMMAND "${CMAKE_COMMAND}" --build "${build_directory}" --target
-      "${CMAKE_COMMAND}" --build "${build_directory}" --target "non-error-test"
+            "non-error-test"
     WORKING_DIRECTORY "${build_directory}"
     RESULT_VARIABLE result_var
     OUTPUT_VARIABLE output_var
     ERROR_VARIABLE output_var)
   if (NOT result_var EQUAL 0)
-    message(SEND_ERROR "Compile error for combined non-error test:\n${output_var}")
+    message(
+      SEND_ERROR "Compile error for combined non-error test:\n${output_var}")
   endif ()
 endfunction ()
 
@@ -120,95 +133,133 @@ expect_compile(check "")
 expect_compile(check-error "compilation_error" ERROR)
 
 # Formatting a wide character with a narrow format string is forbidden.
-expect_compile(wide-character-narrow-format-string "fmt::format(L\"{}\", L'a');")
+expect_compile(wide-character-narrow-format-string
-expect_compile(wide-character-narrow-format-string-error "fmt::format(\"{}\", L'a');" ERROR)
+               "fmt::format(L\"{}\", L'a');")
+expect_compile(wide-character-narrow-format-string-error
+               "fmt::format(\"{}\", L'a');" ERROR)
 
 # Formatting a wide string with a narrow format string is forbidden.
-expect_compile(wide-string-narrow-format-string "fmt::format(L\"{}\", L\"foo\");")
+expect_compile(wide-string-narrow-format-string
-expect_compile(wide-string-narrow-format-string-error "fmt::format(\"{}\", L\"foo\");" ERROR)
+               "fmt::format(L\"{}\", L\"foo\");")
+expect_compile(wide-string-narrow-format-string-error
+               "fmt::format(\"{}\", L\"foo\");" ERROR)
 
 # Formatting a narrow string with a wide format string is forbidden because
 # mixing UTF-8 with UTF-16/32 can result in an invalid output.
-expect_compile(narrow-string-wide-format-string "fmt::format(L\"{}\", L\"foo\");")
+expect_compile(narrow-string-wide-format-string
-expect_compile(narrow-string-wide-format-string-error "fmt::format(L\"{}\", \"foo\");" ERROR)
+               "fmt::format(L\"{}\", L\"foo\");")
+expect_compile(narrow-string-wide-format-string-error
+               "fmt::format(L\"{}\", \"foo\");" ERROR)
 
-expect_compile(cast-to-string "
+expect_compile(
+  cast-to-string
+  "
   struct S {
     operator std::string() const { return std::string(); }
   };
   fmt::format(\"{}\", std::string(S()));
   ")
-expect_compile(cast-to-string-error "
+expect_compile(
+  cast-to-string-error
+  "
   struct S {
     operator std::string() const { return std::string(); }
   };
   fmt::format(\"{}\", S());
-" ERROR)
+  "
+  ERROR)
 
 # Formatting a function
-expect_compile(format-function "
+expect_compile(
+  format-function
+  "
   void (*f)();
   fmt::format(\"{}\", fmt::ptr(f));
   ")
-expect_compile(format-function-error "
+expect_compile(
+  format-function-error
+  "
   void (*f)();
   fmt::format(\"{}\", f);
-" ERROR)
+  "
+  ERROR)
 
 # Formatting an unformattable argument should always be a compile time error
-expect_compile(format-lots-of-arguments-with-unformattable "
+expect_compile(
+  format-lots-of-arguments-with-unformattable
+  "
   struct E {};
   fmt::format(\"\", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, E());
-" ERROR)
+  "
-expect_compile(format-lots-of-arguments-with-function "
+  ERROR)
+expect_compile(
+  format-lots-of-arguments-with-function
+  "
   void (*f)();
   fmt::format(\"\", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, f);
-" ERROR)
+  "
+  ERROR)
 
 if (CMAKE_CXX_STANDARD GREATER_EQUAL 20)
   # Compile-time argument type check
-  expect_compile(format-string-number-spec "
+  expect_compile(
+    format-string-number-spec
+    "
     #ifdef FMT_HAS_CONSTEVAL
       fmt::format(\"{:d}\", 42);
     #endif
     ")
-  expect_compile(format-string-number-spec-error "
+  expect_compile(
+    format-string-number-spec-error
+    "
     #ifdef FMT_HAS_CONSTEVAL
       fmt::format(\"{:d}\", \"I am not a number\");
     #else
       #error
     #endif
-  " ERROR)
+    "
-  expect_compile(print-string-number-spec-error "
+    ERROR)
+  expect_compile(
+    print-string-number-spec-error
+    "
     #ifdef FMT_HAS_CONSTEVAL
       fmt::print(\"{:d}\", \"I am not a number\");
     #else
       #error
     #endif
-  " ERROR)
+    "
-  expect_compile(print-stream-string-number-spec-error "
+    ERROR)
+  expect_compile(
+    print-stream-string-number-spec-error
+    "
   #ifdef FMT_HAS_CONSTEVAL
     fmt::print(std::cout, \"{:d}\", \"I am not a number\");
   #else
     #error
   #endif
-  " ERROR)
+    "
+    ERROR)
 
   # Compile-time argument name check
-  expect_compile(format-string-name "
+  expect_compile(
+    format-string-name
+    "
     #if defined(FMT_HAS_CONSTEVAL) && FMT_USE_NONTYPE_TEMPLATE_ARGS
       using namespace fmt::literals;
       fmt::print(\"{foo}\", \"foo\"_a=42);
     #endif
     ")
-  expect_compile(format-string-name-error "
+  expect_compile(
+    format-string-name-error
+    "
     #if defined(FMT_HAS_CONSTEVAL) && FMT_USE_NONTYPE_TEMPLATE_ARGS
       using namespace fmt::literals;
       fmt::print(\"{foo}\", \"bar\"_a=42);
     #else
       #error
     #endif
-  " ERROR)
+    "
+    ERROR)
 endif ()
 
 # Run all tests

test/cuda-test/CMakeLists.txt

@@ -17,8 +17,8 @@ set(CMAKE_CUDA_STANDARD_REQUIRED 14)
 # In this test, we assume that the user is going to compile CUDA source code
 # with some libraries (fmt in this case).
 #
-# In addition to that, this test invokes both the C++ host compiler and NVCC
+# In addition to that, this test invokes both the C++ host compiler and NVCC by
-# by providing another (non-CUDA) C++ source code.
+# providing another (non-CUDA) C++ source code.
 if (${CMAKE_VERSION} VERSION_LESS 3.15)
   # https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html
   list(APPEND CUDA_NVCC_FLAGS "-std=c++14")
@@ -38,36 +38,40 @@ if (${CMAKE_VERSION} VERSION_LESS 3.15)
     # See Also:
     # https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/
     # https://github.com/Microsoft/vscode-cpptools/issues/2595
-    target_compile_options(fmt-in-cuda-test PRIVATE /Zc:__cplusplus /permissive-)
+    target_compile_options(fmt-in-cuda-test PRIVATE /Zc:__cplusplus
+                                                    /permissive-)
   endif ()
 else ()
   # now using a "new" way of handling CUDA
   add_executable(fmt-in-cuda-test cuda-cpp14.cu cpp14.cc)
-  set_target_properties(fmt-in-cuda-test PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+  set_target_properties(fmt-in-cuda-test PROPERTIES CUDA_SEPARABLE_COMPILATION
+                                                    ON)
   target_compile_features(fmt-in-cuda-test PRIVATE cxx_std_14)
   if (MSVC)
-    # with MSVC, 'cxx_std_14' will only propagate to the host code (MSVC), but will
+    # with MSVC, 'cxx_std_14' will only propagate to the host code (MSVC), but
-    # not set __cplusplus correctly anyway, while nvcc will ignore it.
+    # will not set __cplusplus correctly anyway, while nvcc will ignore it. If
-    # If specified for nvcc on the command line as '-std=c++14' nvcc will emit this
+    # specified for nvcc on the command line as '-std=c++14' nvcc will emit this
-    # message instead:
+    # message instead: nvcc warning : The -std=c++14 flag is not supported with
-    # nvcc warning : The -std=c++14 flag is not supported with the configured host
+    # the configured host compiler. Flag will be ignored.
-    #                compiler. Flag will be ignored.
+    set_property(
-    set_property(SOURCE cuda-cpp14.cu APPEND PROPERTY
+      SOURCE cuda-cpp14.cu
-      COMPILE_OPTIONS -Xcompiler /std:c++14 -Xcompiler /Zc:__cplusplus)
+      APPEND
-    set_property(SOURCE cpp14.cc APPEND PROPERTY
+      PROPERTY COMPILE_OPTIONS -Xcompiler /std:c++14 -Xcompiler /Zc:__cplusplus)
-      COMPILE_OPTIONS /std:c++14 /Zc:__cplusplus)
+    set_property(
+      SOURCE cpp14.cc
+      APPEND
+      PROPERTY COMPILE_OPTIONS /std:c++14 /Zc:__cplusplus)
   endif ()
 endif ()
 
 get_target_property(IN_USE_CUDA_STANDARD fmt-in-cuda-test CUDA_STANDARD)
 message(STATUS "cuda_standard:          ${IN_USE_CUDA_STANDARD}")
 
-get_target_property(IN_USE_CUDA_STANDARD_REQUIRED
+get_target_property(IN_USE_CUDA_STANDARD_REQUIRED fmt-in-cuda-test
-    fmt-in-cuda-test CUDA_STANDARD_REQUIRED)
+                    CUDA_STANDARD_REQUIRED)
 message(STATUS "cuda_standard_required: ${IN_USE_CUDA_STANDARD_REQUIRED}")
 
 # We don't use PUBLIC or other keyword for reasons explained in the
 # CUDA_LINK_LIBRARIES_KEYWORD section in
 # https://cmake.org/cmake/help/latest/module/FindCUDA.html
 target_link_libraries(fmt-in-cuda-test fmt::fmt)
-

test/fuzzing/CMakeLists.txt

@@ -1,5 +1,4 @@
 # Copyright (c) 2019, Paul Dreik
-# License: see LICENSE.rst in the fmt root directory
 
 # Link in the main function. Useful for reproducing, kcov, gdb, afl, valgrind.
 # (Note that libFuzzer can also reproduce, just pass it the files.)
@@ -7,7 +6,9 @@ option(FMT_FUZZ_LINKMAIN "Enables the reproduce mode, instead of libFuzzer" On)
 
 # For oss-fuzz - insert $LIB_FUZZING_ENGINE into the link flags, but only for
 # the fuzz targets, otherwise the CMake configuration step fails.
-set(FMT_FUZZ_LDFLAGS "" CACHE STRING "LDFLAGS for the fuzz targets")
+set(FMT_FUZZ_LDFLAGS
+    ""
+    CACHE STRING "LDFLAGS for the fuzz targets")
 
 # Adds a binary for reproducing, i.e. no fuzzing, just enables replaying data
 # through the fuzzers.
@@ -25,6 +26,7 @@ function(add_fuzzer source)
   target_compile_features(${name} PRIVATE cxx_std_14)
 endfunction ()
 
-foreach (source chrono-duration.cc chrono-timepoint.cc float.cc named-arg.cc one-arg.cc two-args.cc)
+foreach (source chrono-duration.cc chrono-timepoint.cc float.cc named-arg.cc
+                one-arg.cc two-args.cc)
   add_fuzzer(${source})
 endforeach ()

test/gtest/CMakeLists.txt

@@ -1,12 +1,10 @@
-#------------------------------------------------------------------------------
+# Compile Google Test ourselves instead of using pre-compiled libraries. See the
-# Build the google test library
+# Google Test FAQ "Why is it not recommended to install a pre-compiled copy of
+# Google Test (for example, into /usr/local)?" at
+# http://code.google.com/p/googletest/wiki/FAQ for more details.
 
-# Compile Google Test ourselves instead of using pre-compiled libraries.
+add_library(gtest STATIC gmock-gtest-all.cc gmock/gmock.h gtest/gtest.h
-# See the Google Test FAQ "Why is it not recommended to install a
+                         gtest/gtest-spi.h)
-# pre-compiled copy of Google Test (for example, into /usr/local)?"
-# at http://code.google.com/p/googletest/wiki/FAQ for more details.
-add_library(gtest STATIC
-  gmock-gtest-all.cc gmock/gmock.h gtest/gtest.h gtest/gtest-spi.h)
 target_compile_definitions(gtest PUBLIC GTEST_HAS_STD_WSTRING=1)
 target_include_directories(gtest SYSTEM PUBLIC .)
 target_compile_features(gtest PUBLIC cxx_std_11)