coffee/fmt
1
0
Fork 0
mirror of https://github.com/fmtlib/fmt.git synced 2026-04-30 19:09:22 +08:00
Code Issues Packages Projects Releases Wiki Activity

Apply cmake-format

Browse Source
This commit is contained in:
Victor Zverovich 2026-03-03 13:35:11 -08:00
parent eef9ff4938
commit e090e3ffad
9 changed files with 453 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.cmake-format.yaml Normal file
View File

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

218
CMakeLists.txt
View File

@ -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)
# or if it is the master project.
# Determine if fmt is built as a subproject (using add_subdirectory) or if it is
# 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
CMAKE_CXX_STANDARD GREATER_EQUAL 20)
if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.28 AND CMAKE_CXX_STANDARD
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
MSVC_VERSION GREATER_EQUAL 1934)
elseif (CMAKE_GENERATOR MATCHES "^Visual Studio" AND MSVC_VERSION
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
hidden default)
set_property(CACHE CMAKE_CXX_VISIBILITY_PRESET PROPERTY STRINGS hidden
default)
endif ()
if (FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_VISIBILITY_INLINES_HIDDEN)
set_verbose(CMAKE_VISIBILITY_INLINES_HIDDEN ON CACHE BOOL
"Whether to add a compile flag to hide symbols of inline "
"functions.")
set_verbose(
CMAKE_VISIBILITY_INLINES_HIDDEN ON CACHE BOOL
"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
-Wold-style-cast -Wundef
-Wredundant-decls -Wwrite-strings -Wpointer-arith
-Wcast-qual -Wformat=2 -Wmissing-include-dirs
set(PEDANTIC_COMPILE_FLAGS
-pedantic-errors
-Wall
-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
-Winvalid-pch -Woverloaded-virtual
-Wconversion -Wundef
-Wno-ctor-dtor-privacy -Wno-format-nonliteral)
-Wctor-dtor-privacy
-Wdisabled-optimization
-Winvalid-pch
-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}
-Wno-dangling-else -Wno-unused-local-typedefs)
set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wno-dangling-else
-Wno-unused-local-typedefs)
endif ()
if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wdouble-promotion
-Wtrampolines -Wzero-as-null-pointer-constant -Wuseless-cast
-Wvector-operation-performance -Wsized-deallocation -Wshadow)
set(PEDANTIC_COMPILE_FLAGS
${PEDANTIC_COMPILE_FLAGS}
-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
# [12/13/14/15 regression] New (since gcc 12) false positive null-dereference in vector.resize
# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108860
# Workaround for GCC 12-15 regression:
# a false positive null-dereference in vector.resize
# 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
-Wdeprecated -Wweak-vtables -Wshadow
set(PEDANTIC_COMPILE_FLAGS
-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 "
${MSBUILD_SETUP}
file(WRITE run-msbuild.bat "${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}
${FMT_SYSTEM_HEADERS_ATTRIBUTE} BEFORE ${kind}
target_include_directories(
${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
VERSION ${FMT_VERSION}
set_target_properties(
${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
format-inl.h os.h ostream.h printf.h ranges.h std.h xchar.h)
foreach (
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
FILES ${sources})
target_sources(${name} PUBLIC FILE_SET fmt TYPE CXX_MODULES FILES
${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}
-std=c++${std} -x c++-module --precompile -c
-o ${pcm} ${CMAKE_CURRENT_SOURCE_DIR}/${src}
COMMAND
${CMAKE_CXX_COMPILER} -std=c++${std} -x c++-module --precompile -c -o
${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
USE_CMAKE_MODULES ${FMT_USE_CMAKE_MODULES})
add_module_library(fmt-module src/fmt.cc 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(
"${PROJECT_SOURCE_DIR}/support/cmake/fmt.pc.in"
"${pkgconfig}"
configure_file("${PROJECT_SOURCE_DIR}/support/cmake/fmt.pc.in" "${pkgconfig}"
@ONLY)
configure_package_config_file(
${PROJECT_SOURCE_DIR}/support/cmake/fmt-config.cmake.in
${project_config}
${PROJECT_SOURCE_DIR}/support/cmake/fmt-config.cmake.in ${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}
${INSTALL_FILE_SET})
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} ${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
PATHS "$ENV{ProgramFiles}/doxygen/bin"
find_program(DOXYGEN doxygen 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}
-E env PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}/support/python
${MKDOCS} build -f ${CMAKE_CURRENT_SOURCE_DIR}/support/mkdocs.yml
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}/support/python ${MKDOCS} build -f
${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
--no-directory-urls
--site-dir ${CMAKE_CURRENT_BINARY_DIR}/doc-html --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)

8
support/cmake/FindSetEnv.cmake
View File

@ -1,7 +1,11 @@
# A CMake script to find SetEnv.cmd.
find_program(WINSDK_SETENV NAMES SetEnv.cmd
PATHS "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows;CurrentInstallFolder]/bin")
find_program(
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 ()

12
support/cmake/JoinPaths.cmake
View File

@ -1,16 +1,16 @@
# This module provides function for joining paths
# known from from most languages
# This module provides function for joining paths known from from most languages
#
# Original license:
# SPDX-License-Identifier: (MIT OR CC0-1.0)
# Explicit permission given to distribute this module under
# the terms of the project as described in /LICENSE.rst.
# Explicit permission given to distribute this module under the terms of the
# 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 ()

93
test/CMakeLists.txt
View File

@ -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
$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
target_include_directories(
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
${CMAKE_CURRENT_BINARY_DIR}
try_compile(
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
-DFMT_ENFORCE_COMPILE_STRING)
target_compile_definitions(enforce-checks-test
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
posix-mock-test.cc ../src/format.cc ${TEST_MAIN_SRC})
target_include_directories(
posix-mock-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
add_executable(posix-mock-test posix-mock-test.cc ../src/format.cc
${TEST_MAIN_SRC})
target_include_directories(posix-mock-test
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(
noexception-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
target_include_directories(noexception-test
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(
nolocale-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
target_compile_definitions(
nolocale-test PRIVATE FMT_STATIC_THOUSANDS_SEPARATOR=1)
target_include_directories(nolocale-test
PRIVATE ${PROJECT_SOURCE_DIR}/include)
target_compile_definitions(nolocale-test
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
# a space after `operator""` but that is an incorrect syntax for any more
# modern compiler.
if (FMT_PEDANTIC AND NOT WIN32 AND NOT (
CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND
CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9))
# They are disabled on GCC < 4.9 because it can't parse UDLs without a space
# after operator"" but that is an incorrect syntax for any more modern compiler.
if (FMT_PEDANTIC
AND NOT WIN32
AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND CMAKE_CXX_COMPILER_VERSION
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-makeprogram ${CMAKE_MAKE_PROGRAM}
--build-generator
${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}
-C ${CMAKE_BUILD_TYPE}
add_test(
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-makeprogram ${CMAKE_MAKE_PROGRAM}
--build-generator
${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}
-C ${CMAKE_BUILD_TYPE}
add_test(
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-makeprogram ${CMAKE_MAKE_PROGRAM}
--build-generator
${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}
-C ${CMAKE_BUILD_TYPE}
add_test(
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-makeprogram ${CMAKE_MAKE_PROGRAM}
--build-generator
${CMAKE_GENERATOR}
--build-makeprogram
${CMAKE_MAKE_PROGRAM}
--build-options
"-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
"-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"

143
test/compile-error-test/CMakeLists.txt
View File

@ -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}"
"-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
"${CMAKE_COMMAND}" "-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}"
"-DFMT_DIR=${FMT_DIR}"
"-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}" "-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
"${CMAKE_COMMAND}" --build "${build_directory}" --target "test-${test_name}"
COMMAND "${CMAKE_COMMAND}" --build "${build_directory}" --target
"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
"${CMAKE_COMMAND}" --build "${build_directory}" --target "non-error-test"
COMMAND "${CMAKE_COMMAND}" --build "${build_directory}" --target
"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-error "fmt::format(\"{}\", L'a');" ERROR)
expect_compile(wide-character-narrow-format-string
"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-error "fmt::format(\"{}\", L\"foo\");" ERROR)
expect_compile(wide-string-narrow-format-string
"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-error "fmt::format(L\"{}\", \"foo\");" ERROR)
expect_compile(narrow-string-wide-format-string
"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

38
test/cuda-test/CMakeLists.txt
View File

@ -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
# by providing another (non-CUDA) C++ source code.
# In addition to that, this test invokes both the C++ host compiler and NVCC by
# 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
# not set __cplusplus correctly anyway, while nvcc will ignore it.
# If specified for nvcc on the command line as '-std=c++14' nvcc will emit this
# message instead:
# nvcc warning : The -std=c++14 flag is not supported with the configured host
# compiler. Flag will be ignored.
set_property(SOURCE cuda-cpp14.cu APPEND PROPERTY
COMPILE_OPTIONS -Xcompiler /std:c++14 -Xcompiler /Zc:__cplusplus)
set_property(SOURCE cpp14.cc APPEND PROPERTY
COMPILE_OPTIONS /std:c++14 /Zc:__cplusplus)
# with MSVC, 'cxx_std_14' will only propagate to the host code (MSVC), but
# will not set __cplusplus correctly anyway, while nvcc will ignore it. If
# specified for nvcc on the command line as '-std=c++14' nvcc will emit this
# message instead: nvcc warning : The -std=c++14 flag is not supported with
# the configured host compiler. Flag will be ignored.
set_property(
SOURCE cuda-cpp14.cu
APPEND
PROPERTY COMPILE_OPTIONS -Xcompiler /std:c++14 -Xcompiler /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
fmt-in-cuda-test CUDA_STANDARD_REQUIRED)
get_target_property(IN_USE_CUDA_STANDARD_REQUIRED fmt-in-cuda-test
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)

8
test/fuzzing/CMakeLists.txt
View File

@ -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 ()

14
test/gtest/CMakeLists.txt
View File

@ -1,12 +1,10 @@
#------------------------------------------------------------------------------
# Build the google test library
# Compile Google Test ourselves instead of using pre-compiled libraries. See the
# 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.
# See the 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.
add_library(gtest STATIC
gmock-gtest-all.cc gmock/gmock.h gtest/gtest.h gtest/gtest-spi.h)
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)