Fix test

2025-09-29 01:29:35 +08:00 · 2025-05-08 13:45:43 +03:00 · 2025-05-08 13:41:51 +03:00 · 2025-05-08 13:39:44 +03:00 · 2025-05-08 13:34:02 +03:00 · 2025-05-08 13:33:12 +03:00
26 changed files with 314 additions and 238 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,39 +18,38 @@ include(GNUInstallDirs)
 # ---------------------------------------------------------------------------------------
 # Set default build to release
 # ---------------------------------------------------------------------------------------
-if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose Release or Debug" FORCE)
-endif ()
+endif()

 # ---------------------------------------------------------------------------------------
 # Compiler config
 # ---------------------------------------------------------------------------------------
-if (SPDLOG_USE_STD_FORMAT)
+if(SPDLOG_USE_STD_FORMAT)
    set(CMAKE_CXX_STANDARD 20)
    set(CMAKE_CXX_STANDARD_REQUIRED ON)
-elseif (NOT CMAKE_CXX_STANDARD)
+elseif(NOT CMAKE_CXX_STANDARD)
    set(CMAKE_CXX_STANDARD 11)
    set(CMAKE_CXX_STANDARD_REQUIRED ON)
-endif ()
-
+endif()

 set(CMAKE_CXX_EXTENSIONS OFF)

-if (CMAKE_SYSTEM_NAME MATCHES "CYGWIN" OR CMAKE_SYSTEM_NAME MATCHES "MSYS" OR CMAKE_SYSTEM_NAME MATCHES "MINGW")
+if(CMAKE_SYSTEM_NAME MATCHES "CYGWIN" OR CMAKE_SYSTEM_NAME MATCHES "MSYS" OR CMAKE_SYSTEM_NAME MATCHES "MINGW")
    set(CMAKE_CXX_EXTENSIONS ON)
-endif ()
+endif()

 # ---------------------------------------------------------------------------------------
 # Set SPDLOG_MASTER_PROJECT to ON if we are building spdlog
 # ---------------------------------------------------------------------------------------
 # Check if spdlog is being used directly or via add_subdirectory, but allow overriding
-if (NOT DEFINED SPDLOG_MASTER_PROJECT)
-    if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+if(NOT DEFINED SPDLOG_MASTER_PROJECT)
+    if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
        set(SPDLOG_MASTER_PROJECT ON)
-    else ()
+    else()
        set(SPDLOG_MASTER_PROJECT OFF)
-    endif ()
-endif ()
+    endif()
+endif()

 option(SPDLOG_BUILD_ALL "Build all artifacts" OFF)

@@ -77,9 +76,9 @@ option(SPDLOG_BUILD_BENCH "Build benchmarks (Requires https://github.com/google/
 # sanitizer options
 option(SPDLOG_SANITIZE_ADDRESS "Enable address sanitizer in tests" OFF)
 option(SPDLOG_SANITIZE_THREAD "Enable thread sanitizer in tests" OFF)
-if (SPDLOG_SANITIZE_ADDRESS AND SPDLOG_SANITIZE_THREAD)
+if(SPDLOG_SANITIZE_ADDRESS AND SPDLOG_SANITIZE_THREAD)
    message(FATAL_ERROR "SPDLOG_SANITIZE_ADDRESS and SPDLOG_SANITIZE_THREAD are mutually exclusive")
-endif ()
+endif()

 # warning options
 option(SPDLOG_BUILD_WARNINGS "Enable compiler warnings" OFF)
@@ -92,61 +91,61 @@ option(SPDLOG_FMT_EXTERNAL "Use external fmt library instead of bundled" OFF)
 option(SPDLOG_FMT_EXTERNAL_HO "Use external fmt header-only library instead of bundled" OFF)
 option(SPDLOG_NO_EXCEPTIONS "Compile with -fno-exceptions. Call abort() on any spdlog exceptions" OFF)

-if (SPDLOG_FMT_EXTERNAL AND SPDLOG_FMT_EXTERNAL_HO)
+if(SPDLOG_FMT_EXTERNAL AND SPDLOG_FMT_EXTERNAL_HO)
    message(FATAL_ERROR "SPDLOG_FMT_EXTERNAL and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive")
-endif ()
+endif()

-if (SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL_HO)
+if(SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL_HO)
    message(FATAL_ERROR "SPDLOG_USE_STD_FORMAT and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive")
-endif ()
+endif()

-if (SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL)
+if(SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL)
    message(FATAL_ERROR "SPDLOG_USE_STD_FORMAT and SPDLOG_FMT_EXTERNAL are mutually exclusive")
-endif ()
+endif()

 # misc tweakme options
-if (WIN32)
+if(WIN32)
    option(SPDLOG_WCHAR_SUPPORT "Support wchar api" OFF)
    option(SPDLOG_WCHAR_FILENAMES "Support wchar filenames" OFF)
    option(SPDLOG_WCHAR_CONSOLE "Support wchar output to console" OFF)
-else ()
+else()
    set(SPDLOG_WCHAR_SUPPORT OFF CACHE BOOL "non supported option" FORCE)
    set(SPDLOG_WCHAR_FILENAMES OFF CACHE BOOL "non supported option" FORCE)
    set(SPDLOG_WCHAR_CONSOLE OFF CACHE BOOL "non supported option" FORCE)
-endif ()
+endif()

-if (MSVC)
+if(MSVC)
    option(SPDLOG_MSVC_UTF8 "Enable/disable msvc /utf-8 flag required by fmt lib" ON)
-endif ()
+endif()

-if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
    option(SPDLOG_CLOCK_COARSE "Use CLOCK_REALTIME_COARSE instead of the regular clock," OFF)
-else ()
+else()
    set(SPDLOG_CLOCK_COARSE OFF CACHE BOOL "non supported option" FORCE)
-endif ()
+endif()

 option(SPDLOG_PREVENT_CHILD_FD "Prevent from child processes to inherit log file descriptors" OFF)
 option(SPDLOG_NO_THREAD_ID "prevent spdlog from querying the thread id on each log call if thread id is not needed" OFF)
 option(SPDLOG_NO_TLS "prevent spdlog from using thread local storage" OFF)
 option(
-        SPDLOG_NO_ATOMIC_LEVELS
-        "prevent spdlog from using of std::atomic log levels (use only if your code never modifies log levels concurrently"
-        OFF)
+    SPDLOG_NO_ATOMIC_LEVELS
+    "prevent spdlog from using of std::atomic log levels (use only if your code never modifies log levels concurrently"
+    OFF)
 option(SPDLOG_DISABLE_DEFAULT_LOGGER "Disable default logger creation" OFF)
 option(SPDLOG_FWRITE_UNLOCKED "Use the unlocked variant of fwrite. Leave this on unless your libc doesn't have it" ON)

 # clang-tidy
 option(SPDLOG_TIDY "run clang-tidy" OFF)

-if (SPDLOG_TIDY)
+if(SPDLOG_TIDY)
    set(CMAKE_CXX_CLANG_TIDY "clang-tidy")
    set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
    message(STATUS "Enabled clang-tidy")
-endif ()
+endif()

-if (SPDLOG_BUILD_PIC)
+if(SPDLOG_BUILD_PIC)
    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-endif ()
+endif()

 find_package(Threads REQUIRED)
 message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
@@ -155,56 +154,56 @@ message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
 # ---------------------------------------------------------------------------------------
 set(SPDLOG_SRCS src/spdlog.cpp src/stdout_sinks.cpp src/color_sinks.cpp src/file_sinks.cpp src/async.cpp src/cfg.cpp)

-if (NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
    list(APPEND SPDLOG_SRCS src/bundled_fmtlib_format.cpp)
-endif ()
+endif()

-if (SPDLOG_BUILD_SHARED OR BUILD_SHARED_LIBS)
-    if (WIN32)
+if(SPDLOG_BUILD_SHARED OR BUILD_SHARED_LIBS)
+    if(WIN32)
        configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc @ONLY)
        list(APPEND SPDLOG_SRCS ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
-    endif ()
+    endif()
    add_library(spdlog SHARED ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})
    target_compile_definitions(spdlog PUBLIC SPDLOG_SHARED_LIB)
-    if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
        target_compile_options(spdlog PUBLIC $<$<AND:$<CXX_COMPILER_ID:MSVC>,$<NOT:$<COMPILE_LANGUAGE:CUDA>>>:/wd4251
-                /wd4275>)
-    endif ()
-    if (NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+                                             /wd4275>)
+    endif()
+    if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
        target_compile_definitions(spdlog PRIVATE FMT_LIB_EXPORT PUBLIC FMT_SHARED)
-    endif ()
-else ()
+    endif()
+else()
    add_library(spdlog STATIC ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})
-endif ()
+endif()

 add_library(spdlog::spdlog ALIAS spdlog)

 set(SPDLOG_INCLUDES_LEVEL "")
-if (SPDLOG_SYSTEM_INCLUDES)
+if(SPDLOG_SYSTEM_INCLUDES)
    set(SPDLOG_INCLUDES_LEVEL "SYSTEM")
-endif ()
+endif()

 target_compile_definitions(spdlog PUBLIC SPDLOG_COMPILED_LIB)
 target_include_directories(spdlog ${SPDLOG_INCLUDES_LEVEL} PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
-        "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
+                                                                  "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
 target_link_libraries(spdlog PUBLIC Threads::Threads)
 spdlog_enable_warnings(spdlog)

 set_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION
-        ${SPDLOG_VERSION_MAJOR}.${SPDLOG_VERSION_MINOR})
+                                                                  ${SPDLOG_VERSION_MAJOR}.${SPDLOG_VERSION_MINOR})
 set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX d)

-if (COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH)
+if(COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH)
    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pch.h.in ${PROJECT_BINARY_DIR}/spdlog_pch.h @ONLY)
    target_precompile_headers(spdlog PRIVATE ${PROJECT_BINARY_DIR}/spdlog_pch.h)
-endif ()
+endif()

 # sanitizer support
-if (SPDLOG_SANITIZE_ADDRESS)
+if(SPDLOG_SANITIZE_ADDRESS)
    spdlog_enable_addr_sanitizer(spdlog)
-elseif (SPDLOG_SANITIZE_THREAD)
+elseif(SPDLOG_SANITIZE_THREAD)
    spdlog_enable_thread_sanitizer(spdlog)
-endif ()
+endif()

 # ---------------------------------------------------------------------------------------
 # Header only version
@@ -213,132 +212,134 @@ add_library(spdlog_header_only INTERFACE)
 add_library(spdlog::spdlog_header_only ALIAS spdlog_header_only)

 target_include_directories(
-        spdlog_header_only ${SPDLOG_INCLUDES_LEVEL} INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
-        "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
+    spdlog_header_only ${SPDLOG_INCLUDES_LEVEL} INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+                                                          "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
 target_link_libraries(spdlog_header_only INTERFACE Threads::Threads)

 # ---------------------------------------------------------------------------------------
 # Use fmt package if using external fmt
 # ---------------------------------------------------------------------------------------
-if (SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO)
-    if (NOT TARGET fmt::fmt)
+if(SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO)
+    if(NOT TARGET fmt::fmt)
        find_package(fmt CONFIG REQUIRED)
-    endif ()
+    endif()
    target_compile_definitions(spdlog PUBLIC SPDLOG_FMT_EXTERNAL)
    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_FMT_EXTERNAL)

    # use external fmt-header-only
-    if (SPDLOG_FMT_EXTERNAL_HO)
+    if(SPDLOG_FMT_EXTERNAL_HO)
        target_link_libraries(spdlog PUBLIC fmt::fmt-header-only)
        target_link_libraries(spdlog_header_only INTERFACE fmt::fmt-header-only)
-    else () # use external compile fmt
+    else() # use external compile fmt
        target_link_libraries(spdlog PUBLIC fmt::fmt)
        target_link_libraries(spdlog_header_only INTERFACE fmt::fmt)
-    endif ()
+    endif()

    set(PKG_CONFIG_REQUIRES fmt) # add dependency to pkg-config
-endif ()
+endif()

 # ---------------------------------------------------------------------------------------
 # Check if fwrite_unlocked/_fwrite_nolock is available
 # ---------------------------------------------------------------------------------------
-if (SPDLOG_FWRITE_UNLOCKED)
+if(SPDLOG_FWRITE_UNLOCKED)
    include(CheckSymbolExists)
-    if (WIN32)
+    if(WIN32)
        check_symbol_exists(_fwrite_nolock "stdio.h" HAVE_FWRITE_UNLOCKED)
-    else ()
+    else()
        check_symbol_exists(fwrite_unlocked "stdio.h" HAVE_FWRITE_UNLOCKED)
-    endif ()
-    if (HAVE_FWRITE_UNLOCKED)
+    endif()
+    if(HAVE_FWRITE_UNLOCKED)
        target_compile_definitions(spdlog PRIVATE SPDLOG_FWRITE_UNLOCKED)
        target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_FWRITE_UNLOCKED)
-    endif ()
-endif ()
+    endif()
+endif()

 # ---------------------------------------------------------------------------------------
 # Add required libraries for Android CMake build
 # ---------------------------------------------------------------------------------------
-if (ANDROID)
+if(ANDROID)
    target_link_libraries(spdlog PUBLIC log)
    target_link_libraries(spdlog_header_only INTERFACE log)
-endif ()
+endif()

 # ---------------------------------------------------------------------------------------
 # Misc definitions according to tweak options
 # ---------------------------------------------------------------------------------------
 set(SPDLOG_WCHAR_TO_UTF8_SUPPORT ${SPDLOG_WCHAR_SUPPORT})
 set(SPDLOG_UTF8_TO_WCHAR_CONSOLE ${SPDLOG_WCHAR_CONSOLE})
-foreach (
-        SPDLOG_OPTION
-        SPDLOG_WCHAR_TO_UTF8_SUPPORT
-        SPDLOG_UTF8_TO_WCHAR_CONSOLE
-        SPDLOG_WCHAR_FILENAMES
-        SPDLOG_NO_EXCEPTIONS
-        SPDLOG_CLOCK_COARSE
-        SPDLOG_PREVENT_CHILD_FD
-        SPDLOG_NO_THREAD_ID
-        SPDLOG_NO_TLS
-        SPDLOG_NO_ATOMIC_LEVELS
-        SPDLOG_DISABLE_DEFAULT_LOGGER
-        SPDLOG_USE_STD_FORMAT)
-    if (${SPDLOG_OPTION})
+foreach(
+    SPDLOG_OPTION
+    SPDLOG_WCHAR_TO_UTF8_SUPPORT
+    SPDLOG_UTF8_TO_WCHAR_CONSOLE
+    SPDLOG_WCHAR_FILENAMES
+    SPDLOG_NO_EXCEPTIONS
+    SPDLOG_CLOCK_COARSE
+    SPDLOG_PREVENT_CHILD_FD
+    SPDLOG_NO_THREAD_ID
+    SPDLOG_NO_TLS
+    SPDLOG_NO_ATOMIC_LEVELS
+    SPDLOG_DISABLE_DEFAULT_LOGGER
+    SPDLOG_USE_STD_FORMAT)
+    if(${SPDLOG_OPTION})
        target_compile_definitions(spdlog PUBLIC ${SPDLOG_OPTION})
        target_compile_definitions(spdlog_header_only INTERFACE ${SPDLOG_OPTION})
-    endif ()
-endforeach ()
+    endif()
+endforeach()

-if (MSVC)
+if(MSVC)
    target_compile_options(spdlog PRIVATE "/Zc:__cplusplus")
    target_compile_options(spdlog_header_only INTERFACE "/Zc:__cplusplus")
-    if (SPDLOG_MSVC_UTF8)
-        # fmtlib requires the /utf-8 flag when building with msvc.
-        # see https://github.com/fmtlib/fmt/pull/4159 on the purpose of the additional
+    if(SPDLOG_MSVC_UTF8)
+        # fmtlib requires the /utf-8 flag when building with msvc. see https://github.com/fmtlib/fmt/pull/4159 on the
+        # purpose of the additional
        # "$<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>"
        target_compile_options(spdlog PUBLIC $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/utf-8>)
-        target_compile_options(spdlog_header_only INTERFACE $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/utf-8>)
-    endif ()
-endif ()
+        target_compile_options(spdlog_header_only
+                               INTERFACE $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/utf-8>)
+    endif()
+endif()

 # ---------------------------------------------------------------------------------------
 # If exceptions are disabled, disable them in the bundled fmt as well
 # ---------------------------------------------------------------------------------------
-if (SPDLOG_NO_EXCEPTIONS)
-    if (NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
-        target_compile_definitions(spdlog PUBLIC FMT_EXCEPTIONS=0)
-    endif ()
-    if (NOT MSVC)
+if(SPDLOG_NO_EXCEPTIONS)
+    if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+        target_compile_definitions(spdlog PUBLIC FMT_USE_EXCEPTIONS=0)
+    endif()
+    if(NOT MSVC)
        target_compile_options(spdlog PRIVATE -fno-exceptions)
-    else ()
+    else()
        target_compile_options(spdlog PRIVATE /EHs-c-)
-    endif ()
-endif ()
+        target_compile_definitions(spdlog PRIVATE _HAS_EXCEPTIONS=0)
+    endif()
+endif()
 # ---------------------------------------------------------------------------------------
 # Build binaries
 # ---------------------------------------------------------------------------------------
-if (SPDLOG_BUILD_EXAMPLE OR SPDLOG_BUILD_EXAMPLE_HO OR SPDLOG_BUILD_ALL)
+if(SPDLOG_BUILD_EXAMPLE OR SPDLOG_BUILD_EXAMPLE_HO OR SPDLOG_BUILD_ALL)
    message(STATUS "Generating example(s)")
    add_subdirectory(example)
    spdlog_enable_warnings(example)
-    if (SPDLOG_BUILD_EXAMPLE_HO)
+    if(SPDLOG_BUILD_EXAMPLE_HO)
        spdlog_enable_warnings(example_header_only)
-    endif ()
-endif ()
+    endif()
+endif()

-if (SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL)
+if(SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL)
    message(STATUS "Generating tests")
    enable_testing()
    add_subdirectory(tests)
-endif ()
+endif()

-if (SPDLOG_BUILD_BENCH OR SPDLOG_BUILD_ALL)
+if(SPDLOG_BUILD_BENCH OR SPDLOG_BUILD_ALL)
    message(STATUS "Generating benchmarks")
    add_subdirectory(bench)
-endif ()
+endif()

 # ---------------------------------------------------------------------------------------
 # Install
 # ---------------------------------------------------------------------------------------
-if (SPDLOG_INSTALL)
+if(SPDLOG_INSTALL)
    message(STATUS "Generating install")
    set(project_config_in "${CMAKE_CURRENT_LIST_DIR}/cmake/spdlogConfig.cmake.in")
    set(project_config_out "${CMAKE_CURRENT_BINARY_DIR}/spdlogConfig.cmake")
@@ -353,30 +354,30 @@ if (SPDLOG_INSTALL)
    # ---------------------------------------------------------------------------------------
    install(DIRECTORY include/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" PATTERN "fmt/bundled" EXCLUDE)
    install(
-            TARGETS spdlog spdlog_header_only
-            EXPORT spdlog
-            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+        TARGETS spdlog spdlog_header_only
+        EXPORT spdlog
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

-    if (NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+    if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
        install(DIRECTORY include/${PROJECT_NAME}/fmt/bundled/
                DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}/fmt/bundled/")
-    endif ()
+    endif()

    # ---------------------------------------------------------------------------------------
    # Install pkg-config file
    # ---------------------------------------------------------------------------------------
-    if (IS_ABSOLUTE "${CMAKE_INSTALL_INCLUDEDIR}")
+    if(IS_ABSOLUTE "${CMAKE_INSTALL_INCLUDEDIR}")
        set(PKG_CONFIG_INCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}")
-    else ()
+    else()
        set(PKG_CONFIG_INCLUDEDIR "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
-    endif ()
-    if (IS_ABSOLUTE "${CMAKE_INSTALL_LIBDIR}")
+    endif()
+    if(IS_ABSOLUTE "${CMAKE_INSTALL_LIBDIR}")
        set(PKG_CONFIG_LIBDIR "${CMAKE_INSTALL_LIBDIR}")
-    else ()
+    else()
        set(PKG_CONFIG_LIBDIR "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
-    endif ()
+    endif()
    get_target_property(PKG_CONFIG_DEFINES spdlog INTERFACE_COMPILE_DEFINITIONS)
    string(REPLACE ";" " -D" PKG_CONFIG_DEFINES "${PKG_CONFIG_DEFINES}")
    string(CONCAT PKG_CONFIG_DEFINES "-D" "${PKG_CONFIG_DEFINES}")
@@ -387,7 +388,7 @@ if (SPDLOG_INSTALL)
    # Install CMake config files
    # ---------------------------------------------------------------------------------------
    export(TARGETS spdlog spdlog_header_only NAMESPACE spdlog::
-            FILE "${CMAKE_CURRENT_BINARY_DIR}/${config_targets_file}")
+           FILE "${CMAKE_CURRENT_BINARY_DIR}/${config_targets_file}")
    install(EXPORT spdlog DESTINATION ${export_dest_dir} NAMESPACE spdlog:: FILE ${config_targets_file})

    include(CMakePackageConfigHelpers)
@@ -400,4 +401,4 @@ if (SPDLOG_INSTALL)
    # Support creation of installable packages
    # ---------------------------------------------------------------------------------------
    include(cmake/spdlogCPack.cmake)
-endif ()
+endif()
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@ Fast C++ logging library

 ## Install
 #### Header-only version
-Copy the include [folder](https://github.com/gabime/spdlog/tree/v1.x/include/spdlog) to your build tree and use a C++11 compiler.
+Copy the include [folder](include/spdlog) to your build tree and use a C++11 compiler.

 #### Compiled version (recommended - much faster compile times)
 ```console
@@ -19,7 +19,7 @@ $ git clone https://github.com/gabime/spdlog.git
 $ cd spdlog && mkdir build && cd build
 $ cmake .. && cmake --build .
 ```
-see example [CMakeLists.txt](https://github.com/gabime/spdlog/blob/v1.x/example/CMakeLists.txt) on how to use.
+see example [CMakeLists.txt](example/CMakeLists.txt) on how to use.

 ## Platforms
 * Linux, FreeBSD, OpenBSD, Solaris, AIX
@@ -48,7 +48,7 @@ see example [CMakeLists.txt](https://github.com/gabime/spdlog/blob/v1.x/example/
 * Headers only or compiled
 * Feature-rich formatting, using the excellent [fmt](https://github.com/fmtlib/fmt) library.
 * Asynchronous mode (optional)
-* [Custom](https://github.com/gabime/spdlog/wiki/3.-Custom-formatting) formatting.
+* [Custom](https://github.com/gabime/spdlog/wiki/Custom-formatting) formatting.
 * Multi/Single threaded loggers.
 * Various log targets:
  * Rotating log files.
@@ -58,7 +58,7 @@ see example [CMakeLists.txt](https://github.com/gabime/spdlog/blob/v1.x/example/
  * Windows event log.
  * Windows debugger (```OutputDebugString(..)```).
  * Log to Qt widgets ([example](#log-to-qt-with-nice-colors)).
-  * Easily [extendable](https://github.com/gabime/spdlog/wiki/4.-Sinks#implementing-your-own-sink) with custom log targets.
+  * Easily [extendable](https://github.com/gabime/spdlog/wiki/Sinks#implementing-your-own-sink) with custom log targets.
 * Log filtering - log levels can be modified at runtime as well as compile time.
 * Support for loading log levels from argv or environment var.
 * [Backtrace](#backtrace-support) support - store debug messages in a ring buffer and display them later on demand.
@@ -467,7 +467,7 @@ void mdc_example()
 ---
 ## Benchmarks

-Below are some [benchmarks](https://github.com/gabime/spdlog/blob/v1.x/bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
+Below are some [benchmarks](bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz

 #### Synchronous mode
 ```
@@ -519,7 +519,8 @@ Below are some [benchmarks](https://github.com/gabime/spdlog/blob/v1.x/bench/ben
 ```

 ## Documentation
-Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki/1.-QuickStart) pages.
+
+Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki) pages.

 ---

--- a/example/example.cpp
+++ b/example/example.cpp
@@ -269,7 +269,7 @@ void multi_sink_example() {
 struct my_type {
    int i = 0;
    explicit my_type(int i)
-        : i(i){}
+        : i(i) {}
 };

 #ifndef SPDLOG_USE_STD_FORMAT  // when using fmtlib
@@ -382,14 +382,14 @@ void replace_default_logger_example() {
    spdlog::set_default_logger(old_logger);
 }

-// Mapped Diagnostic Context (MDC) is a map that stores key-value pairs (string values) in thread local storage.
-// Each thread maintains its own MDC, which loggers use to append diagnostic information to log outputs.
-// Note: it is not supported in asynchronous mode due to its reliance on thread-local storage.
+// Mapped Diagnostic Context (MDC) is a map that stores key-value pairs (string values) in thread
+// local storage. Each thread maintains its own MDC, which loggers use to append diagnostic
+// information to log outputs. Note: it is not supported in asynchronous mode due to its reliance on
+// thread-local storage.

 #ifndef SPDLOG_NO_TLS
    #include "spdlog/mdc.h"
-void mdc_example()
-{
+void mdc_example() {
    spdlog::mdc::put("key1", "value1");
    spdlog::mdc::put("key2", "value2");
    // if not using the default format, you can use the %& formatter to print mdc data as well
--- a/include/spdlog/async.h
+++ b/include/spdlog/async.h
@@ -89,8 +89,7 @@ inline void init_thread_pool(size_t q_size,
 }

 inline void init_thread_pool(size_t q_size, size_t thread_count) {
-    init_thread_pool(
-        q_size, thread_count, [] {}, [] {});
+    init_thread_pool(q_size, thread_count, [] {}, [] {});
 }

 // get the global thread pool.
--- a/include/spdlog/async_logger-inl.h
+++ b/include/spdlog/async_logger-inl.h
@@ -33,7 +33,7 @@ SPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name,
 // send the log message to the thread pool
 SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg){
    SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){
-        pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
+        pool_ptr -> post_log(shared_from_this(), msg, overflow_policy_);
 }
 else {
    throw_spdlog_ex("async log: thread pool doesn't exist anymore");
@@ -45,7 +45,7 @@ SPDLOG_LOGGER_CATCH(msg.source)
 // send flush request to the thread pool
 SPDLOG_INLINE void spdlog::async_logger::flush_(){
    SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){
-        pool_ptr->post_flush(shared_from_this(), overflow_policy_);
+        pool_ptr -> post_flush(shared_from_this(), overflow_policy_);
 }
 else {
    throw_spdlog_ex("async flush: thread pool doesn't exist anymore");
--- a/include/spdlog/common.h
+++ b/include/spdlog/common.h
@@ -364,7 +364,7 @@ SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(spdlog::wstring_view
 }
 #endif

-#if defined(SPDLOG_USE_STD_FORMAT) &&  __cpp_lib_format >= 202207L
+#if defined(SPDLOG_USE_STD_FORMAT) && __cpp_lib_format >= 202207L
 template <typename T, typename... Args>
 SPDLOG_CONSTEXPR_FUNC std::basic_string_view<T> to_string_view(
    std::basic_format_string<T, Args...> fmt) SPDLOG_NOEXCEPT {
--- a/include/spdlog/details/os-inl.h
+++ b/include/spdlog/details/os-inl.h
@@ -265,10 +265,10 @@ SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) {
    return offset;
 #else

-    #if defined(sun) || defined(__sun) || defined(_AIX) || \
-        (defined(__NEWLIB__) && !defined(__TM_GMTOFF)) ||  \
+    #if defined(sun) || defined(__sun) || defined(_AIX) ||                        \
+        (defined(__NEWLIB__) && !defined(__TM_GMTOFF)) ||                         \
        (!defined(__APPLE__) && !defined(_BSD_SOURCE) && !defined(_GNU_SOURCE) && \
-            (!defined(_POSIX_VERSION) || (_POSIX_VERSION < 202405L)))
+         (!defined(_POSIX_VERSION) || (_POSIX_VERSION < 202405L)))
    // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
    struct helper {
        static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(),
@@ -483,13 +483,12 @@ SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) {
    }

    // find the size to allocate for the result buffer
-    int result_size =
-        ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, NULL, 0);
+    int result_size = ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, NULL, 0);

    if (result_size > 0) {
        target.resize(result_size);
-        result_size = ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, target.data(),
-                                            result_size);
+        result_size =
+            ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, target.data(), result_size);
        if (result_size > 0) {
            assert(result_size == target.size());
            return;
@@ -593,13 +592,13 @@ SPDLOG_INLINE bool fsync(FILE *fp) {
 // Do non-locking fwrite if possible by the os or use the regular locking fwrite
 // Return true on success.
 SPDLOG_INLINE bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp) {
-    #if defined(_WIN32) && defined(SPDLOG_FWRITE_UNLOCKED)
+#if defined(_WIN32) && defined(SPDLOG_FWRITE_UNLOCKED)
    return _fwrite_nolock(ptr, 1, n_bytes, fp) == n_bytes;
-    #elif defined(SPDLOG_FWRITE_UNLOCKED)
+#elif defined(SPDLOG_FWRITE_UNLOCKED)
    return ::fwrite_unlocked(ptr, 1, n_bytes, fp) == n_bytes;
-    #else
+#else
    return std::fwrite(ptr, 1, n_bytes, fp) == n_bytes;
-    #endif
+#endif
 }

 }  // namespace os
--- a/include/spdlog/details/thread_pool-inl.h
+++ b/include/spdlog/details/thread_pool-inl.h
@@ -38,8 +38,7 @@ SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items,
    : thread_pool(q_max_items, threads_n, on_thread_start, [] {}) {}

 SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n)
-    : thread_pool(
-          q_max_items, threads_n, [] {}, [] {}) {}
+    : thread_pool(q_max_items, threads_n, [] {}, [] {}) {}

 // message all threads to terminate gracefully join them
 SPDLOG_INLINE thread_pool::~thread_pool() {
--- a/include/spdlog/fmt/bin_to_hex.h
+++ b/include/spdlog/fmt/bin_to_hex.h
@@ -142,8 +142,8 @@ struct formatter<spdlog::details::dump_info<T>, char> {

    // format the given bytes range as hex
    template <typename FormatContext, typename Container>
-    auto format(const spdlog::details::dump_info<Container> &the_range, FormatContext &ctx) const
-        -> decltype(ctx.out()) {
+    auto format(const spdlog::details::dump_info<Container> &the_range,
+                FormatContext &ctx) const -> decltype(ctx.out()) {
        SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF";
        SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef";
        const char *hex_chars = use_uppercase ? hex_upper : hex_lower;
--- a/include/spdlog/mdc.h
+++ b/include/spdlog/mdc.h
@@ -12,12 +12,14 @@

 #include <spdlog/common.h>

-// MDC is a simple map of key->string values stored in thread local storage whose content will be printed by the loggers.
-// Note: Not supported in async mode (thread local storage - so the async thread pool have different copy).
+// MDC is a simple map of key->string values stored in thread local storage whose content will be
+// printed by the loggers. Note: Not supported in async mode (thread local storage - so the async
+// thread pool have different copy).
 //
 // Usage example:
 // spdlog::mdc::put("mdc_key_1", "mdc_value_1");
-// spdlog::info("Hello, {}", "World!");  // => [2024-04-26 02:08:05.040] [info] [mdc_key_1:mdc_value_1] Hello, World!
+// spdlog::info("Hello, {}", "World!");  // => [2024-04-26 02:08:05.040] [info]
+// [mdc_key_1:mdc_value_1] Hello, World!

 namespace spdlog {
 class SPDLOG_API mdc {
--- a/include/spdlog/sinks/ansicolor_sink-inl.h
+++ b/include/spdlog/sinks/ansicolor_sink-inl.h
@@ -111,7 +111,8 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode_(color_mode mode
 }

 template <typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_(const string_view_t &color_code) const {
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_(
+    const string_view_t &color_code) const {
    details::os::fwrite_bytes(color_code.data(), color_code.size(), target_file_);
 }

--- a/include/spdlog/sinks/callback_sink.h
+++ b/include/spdlog/sinks/callback_sink.h
@@ -27,7 +27,7 @@ public:

 protected:
    void sink_it_(const details::log_msg &msg) override { callback_(msg); }
-    void flush_() override{}
+    void flush_() override {}

 private:
    custom_log_callback callback_;
--- a/include/spdlog/sinks/dup_filter_sink.h
+++ b/include/spdlog/sinks/dup_filter_sink.h
@@ -40,22 +40,21 @@ template <typename Mutex>
 class dup_filter_sink : public dist_sink<Mutex> {
 public:
    template <class Rep, class Period>
-    explicit dup_filter_sink(std::chrono::duration<Rep, Period> max_skip_duration,
-                             level::level_enum notification_level = level::info)
-        : max_skip_duration_{max_skip_duration},
-          log_level_{notification_level} {}
+    explicit dup_filter_sink(std::chrono::duration<Rep, Period> max_skip_duration)
+        : max_skip_duration_{max_skip_duration} {}

 protected:
    std::chrono::microseconds max_skip_duration_;
    log_clock::time_point last_msg_time_;
    std::string last_msg_payload_;
    size_t skip_counter_ = 0;
-    level::level_enum log_level_;
+    level::level_enum skipped_msg_log_level_ = spdlog::level::level_enum::off;

    void sink_it_(const details::log_msg &msg) override {
        bool filtered = filter_(msg);
        if (!filtered) {
            skip_counter_ += 1;
+            skipped_msg_log_level_ = msg.level;
            return;
        }

@@ -65,7 +64,7 @@ protected:
            auto msg_size = ::snprintf(buf, sizeof(buf), "Skipped %u duplicate messages..",
                                       static_cast<unsigned>(skip_counter_));
            if (msg_size > 0 && static_cast<size_t>(msg_size) < sizeof(buf)) {
-                details::log_msg skipped_msg{msg.source, msg.logger_name, log_level_,
+                details::log_msg skipped_msg{msg.source, msg.logger_name, skipped_msg_log_level_,
                                             string_view_t{buf, static_cast<size_t>(msg_size)}};
                dist_sink<Mutex>::sink_it_(skipped_msg);
            }
--- a/include/spdlog/sinks/rotating_file_sink-inl.h
+++ b/include/spdlog/sinks/rotating_file_sink-inl.h
@@ -14,7 +14,6 @@
 #include <spdlog/fmt/fmt.h>

 #include <cerrno>
-#include <chrono>
 #include <ctime>
 #include <mutex>
 #include <string>
@@ -38,8 +37,8 @@ SPDLOG_INLINE rotating_file_sink<Mutex>::rotating_file_sink(
        throw_spdlog_ex("rotating sink constructor: max_size arg cannot be zero");
    }

-    if (max_files > 200000) {
-        throw_spdlog_ex("rotating sink constructor: max_files arg cannot exceed 200000");
+    if (max_files > MaxFiles) {
+        throw_spdlog_ex("rotating sink constructor: max_files arg cannot exceed MaxFiles");
    }
    file_helper_.open(calc_filename(base_filename_, 0));
    current_size_ = file_helper_.size();  // expensive. called only once
@@ -54,11 +53,12 @@ SPDLOG_INLINE rotating_file_sink<Mutex>::rotating_file_sink(
 template <typename Mutex>
 SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::calc_filename(const filename_t &filename,
                                                                  std::size_t index) {
-    if (index == 0u) {
+    if (index == 0U) {
        return filename;
    }

-    filename_t basename, ext;
+    filename_t basename;
+    filename_t ext;
    std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
    return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}.{}{}")), basename, index, ext);
 }
@@ -74,6 +74,35 @@ SPDLOG_INLINE void rotating_file_sink<Mutex>::rotate_now() {
    std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
    rotate_();
 }
+template <typename Mutex>
+SPDLOG_INLINE void rotating_file_sink<Mutex>::set_max_size(std::size_t max_size) {
+    std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+    if (max_size == 0) {
+        throw_spdlog_ex("rotating sink set_max_size: max_size arg cannot be zero");
+    }
+    max_size_ = max_size;
+}
+
+template <typename Mutex>
+SPDLOG_INLINE std::size_t rotating_file_sink<Mutex>::get_max_size() {
+    std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+    return max_size_;
+}
+
+template <typename Mutex>
+SPDLOG_INLINE void rotating_file_sink<Mutex>::set_max_files(std::size_t max_files) {
+    std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+    if (max_files > MaxFiles) {
+        throw_spdlog_ex("rotating sink set_max_files: max_files arg cannot exceed 200000");
+    }
+    max_files_ = max_files;
+}
+
+template <typename Mutex>
+std::size_t rotating_file_sink<Mutex>::get_max_files() {
+    std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+    return max_files_;
+}

 template <typename Mutex>
 SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const details::log_msg &msg) {
--- a/include/spdlog/sinks/rotating_file_sink.h
+++ b/include/spdlog/sinks/rotating_file_sink.h
@@ -8,7 +8,6 @@
 #include <spdlog/details/synchronous_factory.h>
 #include <spdlog/sinks/base_sink.h>

-#include <chrono>
 #include <mutex>
 #include <string>

@@ -21,6 +20,7 @@ namespace sinks {
 template <typename Mutex>
 class rotating_file_sink final : public base_sink<Mutex> {
 public:
+    static constexpr size_t MaxFiles = 200000;
    rotating_file_sink(filename_t base_filename,
                       std::size_t max_size,
                       std::size_t max_files,
@@ -29,6 +29,10 @@ public:
    static filename_t calc_filename(const filename_t &filename, std::size_t index);
    filename_t filename();
    void rotate_now();
+    void set_max_size(std::size_t max_size);
+    std::size_t get_max_size();
+    void set_max_files(std::size_t max_files);
+    std::size_t get_max_files();

 protected:
    void sink_it_(const details::log_msg &msg) override;
@@ -42,7 +46,7 @@ private:
    // log.3.txt -> delete
    void rotate_();

-    // delete the target if exists, and rename the src file  to target
+    // delete the target if exists, and rename the src file to target
    // return true on success, false otherwise.
    bool rename_file_(const filename_t &src_filename, const filename_t &target_filename);

@@ -61,25 +65,24 @@ using rotating_file_sink_st = rotating_file_sink<details::null_mutex>;
 //
 // factory functions
 //
-
 template <typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> rotating_logger_mt(const std::string &logger_name,
-                                                  const filename_t &filename,
-                                                  size_t max_file_size,
-                                                  size_t max_files,
-                                                  bool rotate_on_open = false,
-                                                  const file_event_handlers &event_handlers = {}) {
+std::shared_ptr<logger> rotating_logger_mt(const std::string &logger_name,
+                                           const filename_t &filename,
+                                           size_t max_file_size,
+                                           size_t max_files,
+                                           bool rotate_on_open = false,
+                                           const file_event_handlers &event_handlers = {}) {
    return Factory::template create<sinks::rotating_file_sink_mt>(
        logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
 }

 template <typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> rotating_logger_st(const std::string &logger_name,
-                                                  const filename_t &filename,
-                                                  size_t max_file_size,
-                                                  size_t max_files,
-                                                  bool rotate_on_open = false,
-                                                  const file_event_handlers &event_handlers = {}) {
+std::shared_ptr<logger> rotating_logger_st(const std::string &logger_name,
+                                           const filename_t &filename,
+                                           size_t max_file_size,
+                                           size_t max_files,
+                                           bool rotate_on_open = false,
+                                           const file_event_handlers &event_handlers = {}) {
    return Factory::template create<sinks::rotating_file_sink_st>(
        logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
 }
--- a/include/spdlog/sinks/wincolor_sink-inl.h
+++ b/include/spdlog/sinks/wincolor_sink-inl.h
@@ -137,10 +137,10 @@ void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::print_range_(const memory_buf_t
 #if defined(SPDLOG_UTF8_TO_WCHAR_CONSOLE)
        wmemory_buf_t wformatted;
        details::os::utf8_to_wstrbuf(string_view_t(formatted.data() + start, end - start),
-            wformatted);
+                                     wformatted);
        auto size = static_cast<DWORD>(wformatted.size());
        auto ignored = ::WriteConsoleW(static_cast<HANDLE>(out_handle_), wformatted.data(), size,
-            nullptr, nullptr);
+                                       nullptr, nullptr);
 #else
        auto size = static_cast<DWORD>(end - start);
        auto ignored = ::WriteConsoleA(static_cast<HANDLE>(out_handle_), formatted.data() + start,
--- a/include/spdlog/tweakme.h
+++ b/include/spdlog/tweakme.h
@@ -109,8 +109,8 @@
 //
 // #include <string_view>
 // using namespace std::string_view_literals;
-// #define SPDLOG_LEVEL_NAMES { "MY TRACE"sv, "MY DEBUG"sv, "MY INFO"sv, "MY WARNING"sv, "MY ERROR"sv, "MY
-// CRITICAL"sv, "OFF"sv }
+// #define SPDLOG_LEVEL_NAMES { "MY TRACE"sv, "MY DEBUG"sv, "MY INFO"sv, "MY WARNING"sv, "MY
+// ERROR"sv, "MY CRITICAL"sv, "OFF"sv }
 ///////////////////////////////////////////////////////////////////////////////

 ///////////////////////////////////////////////////////////////////////////////
--- a/src/bundled_fmtlib_format.cpp
+++ b/src/bundled_fmtlib_format.cpp
@@ -13,34 +13,32 @@
 FMT_BEGIN_NAMESPACE
 namespace detail {

-template FMT_API auto dragonbox::to_decimal(float x) noexcept
-    -> dragonbox::decimal_fp<float>;
-template FMT_API auto dragonbox::to_decimal(double x) noexcept
-    -> dragonbox::decimal_fp<double>;
+template FMT_API auto dragonbox::to_decimal(float x) noexcept -> dragonbox::decimal_fp<float>;
+template FMT_API auto dragonbox::to_decimal(double x) noexcept -> dragonbox::decimal_fp<double>;

-#if FMT_USE_LOCALE
+    #if FMT_USE_LOCALE
 // DEPRECATED! locale_ref in the detail namespace
 template FMT_API locale_ref::locale_ref(const std::locale& loc);
 template FMT_API auto locale_ref::get<std::locale>() const -> std::locale;
-#endif
+    #endif

 // Explicit instantiations for char.

-template FMT_API auto thousands_sep_impl(locale_ref)
-    -> thousands_sep_result<char>;
+template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result<char>;
 template FMT_API auto decimal_point_impl(locale_ref) -> char;

 // DEPRECATED!
 template FMT_API void buffer<char>::append(const char*, const char*);

 // DEPRECATED!
-template FMT_API void vformat_to(buffer<char>&, string_view,
-                                 typename vformat_args<>::type, locale_ref);
+template FMT_API void vformat_to(buffer<char>&,
+                                 string_view,
+                                 typename vformat_args<>::type,
+                                 locale_ref);

 // Explicit instantiations for wchar_t.

-template FMT_API auto thousands_sep_impl(locale_ref)
-    -> thousands_sep_result<wchar_t>;
+template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result<wchar_t>;
 template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;

 template FMT_API void buffer<wchar_t>::append(const wchar_t*, const wchar_t*);
@@ -48,5 +46,4 @@ template FMT_API void buffer<wchar_t>::append(const wchar_t*, const wchar_t*);
 }  // namespace detail
 FMT_END_NAMESPACE

-
 #endif  // !SPDLOG_FMT_EXTERNAL
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -19,9 +19,9 @@ if(Catch2_FOUND)
 else()
    message(STATUS "Bundled version of Catch will be downloaded and used.")
    include(FetchContent)
-    FetchContent_Declare(Catch2
-            GIT_REPOSITORY https://github.com/catchorg/Catch2.git
-            GIT_TAG 53d0d913a422d356b23dd927547febdf69ee9081 # v3.5.0
+    FetchContent_Declare(
+        Catch2 GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+        GIT_TAG 53d0d913a422d356b23dd927547febdf69ee9081 # v3.5.0
    )
    FetchContent_MakeAvailable(Catch2)
 endif()
@@ -71,9 +71,9 @@ function(spdlog_prepare_test test_target spdlog_lib)
    target_link_libraries(${test_target} PRIVATE Catch2::Catch2WithMain)
    if(SPDLOG_SANITIZE_ADDRESS)
        spdlog_enable_addr_sanitizer(${test_target})
-    elseif (SPDLOG_SANITIZE_THREAD)
+    elseif(SPDLOG_SANITIZE_THREAD)
        spdlog_enable_thread_sanitizer(${test_target})
-    endif ()
+    endif()
    add_test(NAME ${test_target} COMMAND ${test_target})
    set_tests_properties(${test_target} PROPERTIES RUN_SERIAL ON)
 endfunction()
--- a/tests/test_custom_callbacks.cpp
+++ b/tests/test_custom_callbacks.cpp
@@ -16,7 +16,8 @@ TEST_CASE("custom_callback_logger", "[custom_callback_logger]") {
            spdlog::memory_buf_t formatted;
            formatter.format(msg, formatted);
            auto eol_len = strlen(spdlog::details::os::default_eol);
-            using diff_t = typename std::iterator_traits<decltype(formatted.end())>::difference_type; 
+            using diff_t =
+                typename std::iterator_traits<decltype(formatted.end())>::difference_type;
            lines.emplace_back(formatted.begin(), formatted.end() - static_cast<diff_t>(eol_len));
        });
    std::shared_ptr<spdlog::sinks::test_sink_st> test_sink(new spdlog::sinks::test_sink_st);
--- a/tests/test_daily_logger.cpp
+++ b/tests/test_daily_logger.cpp
@@ -46,10 +46,8 @@ TEST_CASE("daily_logger with dateonly calculator", "[daily_logger]") {

 struct custom_daily_file_name_calculator {
    static spdlog::filename_t calc_filename(const spdlog::filename_t &basename, const tm &now_tm) {
-        
-        return spdlog::fmt_lib::format(SPDLOG_FILENAME_T("{}{:04d}{:02d}{:02d}"),
-                                   basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1,
-                                   now_tm.tm_mday);        
+        return spdlog::fmt_lib::format(SPDLOG_FILENAME_T("{}{:04d}{:02d}{:02d}"), basename,
+                                       now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday);
    }
 };

--- a/tests/test_file_logging.cpp
+++ b/tests/test_file_logging.cpp
@@ -94,14 +94,11 @@ TEST_CASE("rotating_file_logger2", "[rotating_logger]") {
        // next logger can rename the first output file.
        spdlog::drop(logger->name());
    }
-
    auto logger = spdlog::rotating_logger_mt("logger", basename, max_size, 2, true);
    for (int i = 0; i < 10; ++i) {
        logger->info("Test message {}", i);
    }
-
    logger->flush();
-
    require_message_count(ROTATING_LOG, 10);

    for (int i = 0; i < 1000; i++) {
@@ -141,3 +138,50 @@ TEST_CASE("rotating_file_logger4", "[rotating_logger]") {
    REQUIRE(get_filesize(ROTATING_LOG) > 0);
    REQUIRE(get_filesize(ROTATING_LOG ".1") > 0);
 }
+
+// test changing the max size of the rotating file sink
+TEST_CASE("rotating_file_logger5", "[rotating_logger]") {
+    prepare_logdir();
+    size_t max_size = 5 * 1024;
+    size_t max_files = 2;
+    spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG);
+    auto sink =
+        std::make_shared<spdlog::sinks::rotating_file_sink_st>(basename, max_size, max_files);
+    auto logger = std::make_shared<spdlog::logger>("rotating_sink_logger", sink);
+    logger->set_pattern("%v");
+
+    REQUIRE(sink->get_max_size() == max_size);
+    REQUIRE(sink->get_max_files() == max_files);
+    max_size = 7 * 1024;
+    max_files = 3;
+
+    sink->set_max_size(max_size);
+    sink->set_max_files(max_files);
+    REQUIRE(sink->get_max_size() == max_size);
+    REQUIRE(sink->get_max_files() == max_files);
+
+    const auto message = std::string(200, 'x');
+    assert(message.size() < max_size);
+    const auto n_messages = max_files * max_size / message.size();
+    for (size_t i = 0; i < n_messages; ++i) {
+        logger->info(message);
+    }
+    logger.reset();  // force flush and close the file
+
+    // validate that the files were rotated correctly with the new max size and max files
+    for (size_t i = 0; i <= max_files; i++) {
+        // calc filenames
+        // e.g. rotating_log, rotating_log.0 rotating_log.1, rotating_log.2, etc.
+        std::ostringstream oss;
+        oss << ROTATING_LOG;
+        if (i > 0) {
+            oss << '.' << i;
+        }
+        const auto filename = oss.str();
+        const auto filesize = get_filesize(filename);
+        REQUIRE(filesize <= max_size);
+        if (i > 0) {
+            REQUIRE(filesize >= max_size - message.size() - 2);
+        }
+    }
+}
--- a/tests/test_misc.cpp
+++ b/tests/test_misc.cpp
@@ -1,12 +1,12 @@
-#ifdef _WIN32 // to prevent fopen warning on windows
-#define _CRT_SECURE_NO_WARNINGS
+#ifdef _WIN32  // to prevent fopen warning on windows
+    #define _CRT_SECURE_NO_WARNINGS
 #endif

 #include "includes.h"
 #include "test_sink.h"

 template <class T>
-std::string log_info(const T &what, spdlog::level::level_enum logger_level = spdlog::level::info) {
+std::string log_info(const T& what, spdlog::level::level_enum logger_level = spdlog::level::info) {
    std::ostringstream oss;
    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);

@@ -182,17 +182,19 @@ TEST_CASE("utf8 to utf16 conversion using windows api", "[windows utf]") {
    spdlog::details::os::utf8_to_wstrbuf("abc", buffer);
    REQUIRE(std::wstring(buffer.data(), buffer.size()) == std::wstring(L"abc"));

-    spdlog::details::os::utf8_to_wstrbuf("\xc3\x28", buffer); // Invalid UTF-8 sequence.
+    spdlog::details::os::utf8_to_wstrbuf("\xc3\x28", buffer);  // Invalid UTF-8 sequence.
    REQUIRE(std::wstring(buffer.data(), buffer.size()) == std::wstring(L"\xfffd("));

-    spdlog::details::os::utf8_to_wstrbuf("\xe3\x81\xad\xe3\x81\x93", buffer); // "Neko" in hiragana.
+    spdlog::details::os::utf8_to_wstrbuf("\xe3\x81\xad\xe3\x81\x93",
+                                         buffer);  // "Neko" in hiragana.
    REQUIRE(std::wstring(buffer.data(), buffer.size()) == std::wstring(L"\x306d\x3053"));
 }
 #endif

 struct auto_closer {
    FILE* fp = nullptr;
-    explicit auto_closer(FILE* f) : fp(f) {}
+    explicit auto_closer(FILE* f)
+        : fp(f) {}
    auto_closer(const auto_closer&) = delete;
    auto_closer& operator=(const auto_closer&) = delete;
    ~auto_closer() {
@@ -201,10 +203,10 @@ struct auto_closer {
 };

 TEST_CASE("os::fwrite_bytes", "[os]") {
-    using spdlog::details::os::fwrite_bytes;
    using spdlog::details::os::create_dir;
+    using spdlog::details::os::fwrite_bytes;
    const char* filename = "log_tests/test_fwrite_bytes.txt";
-    const char *msg = "hello";
+    const char* msg = "hello";
    prepare_logdir();
    REQUIRE(create_dir(SPDLOG_FILENAME_T("log_tests")) == true);
    {
--- a/tests/test_pattern_formatter.cpp
+++ b/tests/test_pattern_formatter.cpp
@@ -23,7 +23,9 @@ static std::string log_to_str(const std::string &msg, const Args &...args) {

 // log to str and return it with time
 template <typename... Args>
-static std::string log_to_str_with_time(spdlog::log_clock::time_point log_time, const std::string &msg, const Args &...args) {
+static std::string log_to_str_with_time(spdlog::log_clock::time_point log_time,
+                                        const std::string &msg,
+                                        const Args &...args) {
    std::ostringstream oss;
    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
    spdlog::logger oss_logger("pattern_tester", oss_sink);
@@ -80,8 +82,8 @@ TEST_CASE("GMT offset ", "[pattern_formatter]") {
    const auto now = std::chrono::system_clock::now();
    const auto yesterday = now - 24h;

-    REQUIRE(log_to_str_with_time(yesterday, "Some message", "%z", spdlog::pattern_time_type::utc, "\n") ==
-            "+00:00\n");
+    REQUIRE(log_to_str_with_time(yesterday, "Some message", "%z", spdlog::pattern_time_type::utc,
+                                 "\n") == "+00:00\n");
 }

 TEST_CASE("color range test1", "[pattern_formatter]") {
--- a/tests/utils.cpp
+++ b/tests/utils.cpp
@@ -50,9 +50,8 @@ void require_message_count(const std::string &filename, const std::size_t messag
 std::size_t get_filesize(const std::string &filename) {
    std::ifstream ifs(filename, std::ifstream::ate | std::ifstream::binary);
    if (!ifs) {
-        throw std::runtime_error("Failed open file ");
+        throw std::runtime_error("Failed open file " + filename);
    }
-
    return static_cast<std::size_t>(ifs.tellg());
 }
Author	SHA1	Message	Date
gabime	d8820dcb44	Fix test	2025-05-08 13:45:43 +03:00
gabime	37e8a77862	Fix test	2025-05-08 13:41:51 +03:00
gabime	762c238135	Fix test	2025-05-08 13:39:44 +03:00
gabime	9a86d1f2ba	clang format	2025-05-08 13:34:02 +03:00
gabime	493f5b0581	Fix #3379	2025-05-08 13:33:12 +03:00
Hinageshi	548b264254	Fix warning C4530 (#3393 ) * Fix warning C4530 * Rename FMT_EXCEPTIONS to FMT_USE_EXCEPTIONS	2025-04-23 19:46:25 +03:00
Tihran Katolikian	847db3375f	dup_filter_sink: remove notification_level argument; use last message log level for notification instead (#3390 )	2025-04-18 20:45:56 +03:00
Dmitry Kozlovtsev	bb8694b50f	Fix links for #3380 (#3381 )	2025-04-14 19:22:47 +03:00
Christoph Gringmuth	cec28bf839	Fix links to local reference. (#3378 ) Enables local navigation in IDE and removes links to branch.	2025-04-10 17:58:19 +03:00
Gabi Melman	bd0609d7a0	Update README.md	2025-04-10 17:06:12 +03:00
Christoph Gringmuth	1f4959c832	Fix link to wiki. (#3377 )	2025-04-10 17:04:23 +03:00