Git-Mirrors/keepassxc
1
0
Fork 0
mirror of https://github.com/keepassxreboot/keepassxc.git synced 2024-10-01 01:26:01 -04:00
Code Issues Packages Projects Releases Wiki Activity
f7735afcd6
keepassxc/cmake/CodeCoverage.cmake

244 lines
10 KiB
CMake
Raw Normal View History

Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
# Copyright (c) 2012 - 2017, Lars Bilke
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
# Copyright (c) 2021 KeePassXC Team
Updated README badges and added code coverage
2016-11-04 00:47:04 -04:00
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
#
# 3. Neither the name of the copyright holder nor the names of its contributors
# may be used to endorse or promote products derived from this software without
# specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
include(CMakeParseArguments)
Updated README badges and added code coverage
2016-11-04 00:47:04 -04:00
# Check prereqs
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
find_program(GCOV_PATH gcov)
find_program(LLVM_COV_PATH llvm-cov)
find_program(LLVM_PROFDATA_PATH llvm-profdata)
find_program(XCRUN_PATH xcrun)
find_program(GENHTML_PATH NAMES genhtml genhtml.perl genhtml.bat)
find_program(GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
set(COVERAGE_COMPILER_FLAGS "-g -O0" CACHE INTERNAL "")
if(CMAKE_COMPILER_IS_GNUCXX)
set(COVERAGE_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} --coverage -fprofile-arcs -ftest-coverage")
elseif(CMAKE_COMPILER_IS_CLANGXX)
set(COVERAGE_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-instr-generate -fcoverage-mapping")
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
endif()
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
set(CMAKE_COVERAGE_FORMAT
Clean up code coverage reporting. CTest is now run directly and `make coverage` (like `make test`) now expects you to run `make` beforehand, which is more flexible for the user. This patch also reduces clutter by properly excluding unwanted files and reduces the number of explicit exlusion regexes that are required. Gcov reports are still confusing and report very low branch coverage (which is picked up by Codecov, unfortunately), but the llvm-cov reports are nice and clean now.
2021-09-27 08:13:30 -04:00
"html" "xml"
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
CACHE STRING "Coverage report output format.")
set_property(CACHE CMAKE_COVERAGE_FORMAT PROPERTY STRINGS "html" "txt")
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
set(CMAKE_CXX_FLAGS_COVERAGE
${COVERAGE_COMPILER_FLAGS}
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
CACHE STRING "Flags used by the C++ compiler during coverage builds.")
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
set(CMAKE_C_FLAGS_COVERAGE
${COVERAGE_COMPILER_FLAGS}
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
CACHE STRING "Flags used by the C compiler during coverage builds.")
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
Updated README badges and added code coverage
2016-11-04 00:47:04 -04:00
""
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
CACHE STRING "Flags used for linking binaries during coverage builds.")
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
Updated README badges and added code coverage
2016-11-04 00:47:04 -04:00
""
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
CACHE STRING "Flags used by the shared libraries linker during coverage builds.")
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
mark_as_advanced(
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
CMAKE_COVERAGE_FORMAT
Updated README badges and added code coverage
2016-11-04 00:47:04 -04:00
CMAKE_CXX_FLAGS_COVERAGE
CMAKE_C_FLAGS_COVERAGE
CMAKE_EXE_LINKER_FLAGS_COVERAGE
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
CMAKE_SHARED_LINKER_FLAGS_COVERAGE)
Updated README badges and added code coverage
2016-11-04 00:47:04 -04:00
Windows: use winqtdeploy instead of DeplyQt4 from CMake (#3025) * Ensure Qt dlls find plugins in bundled directory * Reduce complexity of deployment code * Standardize use of CMAKE_BUILD_TYPE_LOWER for more robust comparisons Fixes #3023. Fixes part of #1535.
2019-04-20 12:12:00 -04:00
if(NOT CMAKE_BUILD_TYPE_LOWER STREQUAL "debug")
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
endif() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug"
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
if(CMAKE_COMPILER_IS_GNUCXX)
if(NOT GCOV_PATH)
message(FATAL_ERROR "gcov not found! Aborting...")
endif() # NOT GCOV_PATH
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
link_libraries(gcov)
endif()
# Defines a target for running and collection code coverage information
# Builds dependencies, runs the given executable and outputs reports.
# NOTE! The executable should always have a ZERO as exit code otherwise
# the coverage generation will not complete.
#
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
# SETUP_TARGET_FOR_COVERAGE_GCOVR(
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
# NAME ctest_coverage # New target name
# EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
# DEPENDENCIES executable_target # Dependencies to build first
# )
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
function(SETUP_TARGET_FOR_COVERAGE_GCOVR)
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
set(options NONE)
Clean up code coverage reporting. CTest is now run directly and `make coverage` (like `make test`) now expects you to run `make` beforehand, which is more flexible for the user. This patch also reduces clutter by properly excluding unwanted files and reduces the number of explicit exlusion regexes that are required. Gcov reports are still confusing and report very low branch coverage (which is picked up by Codecov, unfortunately), but the llvm-cov reports are nice and clean now.
2021-09-27 08:13:30 -04:00
set(oneValueArgs NAME SOURCES_ROOT)
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
if(NOT GCOVR_PATH)
message(FATAL_ERROR "gcovr not found! Aborting...")
endif() # NOT GCOVR_PATH
# Combine excludes to several -e arguments
set(GCOVR_EXCLUDES "")
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
foreach(EXCLUDE ${COVERAGE_EXCLUDES})
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
list(APPEND GCOVR_EXCLUDES "-e")
list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
endforeach()
add_custom_target(${Coverage_NAME}
# Run tests
Clean up code coverage reporting. CTest is now run directly and `make coverage` (like `make test`) now expects you to run `make` beforehand, which is more flexible for the user. This patch also reduces clutter by properly excluding unwanted files and reduces the number of explicit exlusion regexes that are required. Gcov reports are still confusing and report very low branch coverage (which is picked up by Codecov, unfortunately), but the llvm-cov reports are nice and clean now.
2021-09-27 08:13:30 -04:00
COMMAND ctest -C $<CONFIG> $ENV{ARGS} $$ARGS
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
DEPENDS ${Coverage_DEPENDENCIES}
)
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
if("html" IN_LIST CMAKE_COVERAGE_FORMAT)
add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
Clean up code coverage reporting. CTest is now run directly and `make coverage` (like `make test`) now expects you to run `make` beforehand, which is more flexible for the user. This patch also reduces clutter by properly excluding unwanted files and reduces the number of explicit exlusion regexes that are required. Gcov reports are still confusing and report very low branch coverage (which is picked up by Codecov, unfortunately), but the llvm-cov reports are nice and clean now.
2021-09-27 08:13:30 -04:00
# Create folder
COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/${Coverage_NAME}-html
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
# Running gcovr HTML
COMMAND ${GCOVR_PATH} --html --html-details
Clean up code coverage reporting. CTest is now run directly and `make coverage` (like `make test`) now expects you to run `make` beforehand, which is more flexible for the user. This patch also reduces clutter by properly excluding unwanted files and reduces the number of explicit exlusion regexes that are required. Gcov reports are still confusing and report very low branch coverage (which is picked up by Codecov, unfortunately), but the llvm-cov reports are nice and clean now.
2021-09-27 08:13:30 -04:00
-r ${Coverage_SOURCES_ROOT} ${GCOVR_EXCLUDES}
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
--object-directory=${PROJECT_BINARY_DIR}
Clean up code coverage reporting. CTest is now run directly and `make coverage` (like `make test`) now expects you to run `make` beforehand, which is more flexible for the user. This patch also reduces clutter by properly excluding unwanted files and reduces the number of explicit exlusion regexes that are required. Gcov reports are still confusing and report very low branch coverage (which is picked up by Codecov, unfortunately), but the llvm-cov reports are nice and clean now.
2021-09-27 08:13:30 -04:00
--exclude-unreachable-branches --exclude-throw-branches
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
-o ${Coverage_NAME}-html/index.html
WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
COMMENT "Running gcovr to produce HTML code coverage report ${Coverage_NAME}-html."
)
endif()
Clean up code coverage reporting. CTest is now run directly and `make coverage` (like `make test`) now expects you to run `make` beforehand, which is more flexible for the user. This patch also reduces clutter by properly excluding unwanted files and reduces the number of explicit exlusion regexes that are required. Gcov reports are still confusing and report very low branch coverage (which is picked up by Codecov, unfortunately), but the llvm-cov reports are nice and clean now.
2021-09-27 08:13:30 -04:00
if("xml" IN_LIST CMAKE_COVERAGE_FORMAT)
add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
# Running gcovr TXT
COMMAND ${GCOVR_PATH} --xml
-r ${Coverage_SOURCES_ROOT} ${GCOVR_EXCLUDES}
--object-directory=${PROJECT_BINARY_DIR}
--exclude-unreachable-branches --exclude-throw-branches
-o ${Coverage_NAME}.xml
WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
COMMENT "Running gcovr to produce XML code coverage report ${Coverage_NAME}.xml."
)
endif()
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
if("txt" IN_LIST CMAKE_COVERAGE_FORMAT)
add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
Clean up code coverage reporting. CTest is now run directly and `make coverage` (like `make test`) now expects you to run `make` beforehand, which is more flexible for the user. This patch also reduces clutter by properly excluding unwanted files and reduces the number of explicit exlusion regexes that are required. Gcov reports are still confusing and report very low branch coverage (which is picked up by Codecov, unfortunately), but the llvm-cov reports are nice and clean now.
2021-09-27 08:13:30 -04:00
# Running gcovr TXT
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
COMMAND ${GCOVR_PATH}
Clean up code coverage reporting. CTest is now run directly and `make coverage` (like `make test`) now expects you to run `make` beforehand, which is more flexible for the user. This patch also reduces clutter by properly excluding unwanted files and reduces the number of explicit exlusion regexes that are required. Gcov reports are still confusing and report very low branch coverage (which is picked up by Codecov, unfortunately), but the llvm-cov reports are nice and clean now.
2021-09-27 08:13:30 -04:00
-r ${Coverage_SOURCES_ROOT} ${GCOVR_EXCLUDES}
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
--object-directory=${PROJECT_BINARY_DIR}
Clean up code coverage reporting. CTest is now run directly and `make coverage` (like `make test`) now expects you to run `make` beforehand, which is more flexible for the user. This patch also reduces clutter by properly excluding unwanted files and reduces the number of explicit exlusion regexes that are required. Gcov reports are still confusing and report very low branch coverage (which is picked up by Codecov, unfortunately), but the llvm-cov reports are nice and clean now.
2021-09-27 08:13:30 -04:00
--exclude-unreachable-branches --exclude-throw-branches
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
-o ${Coverage_NAME}.txt
WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
COMMENT "Running gcovr to produce TXT code coverage report ${Coverage_NAME}.txt."
)
endif()
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
endfunction() # SETUP_TARGET_FOR_COVERAGE_GCOVR
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
# Defines a target for running and collection code coverage information
# Builds dependencies, runs the given executable and outputs reports.
# NOTE! The executable should always have a ZERO as exit code otherwise
# the coverage generation will not complete.
#
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
# SETUP_TARGET_FOR_COVERAGE_LLVM(
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
# NAME ctest_coverage # New target name
# EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
# DEPENDENCIES executable_target # Dependencies to build first
# )
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
function(SETUP_TARGET_FOR_COVERAGE_LLVM)
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
set(options NONE)
Clean up code coverage reporting. CTest is now run directly and `make coverage` (like `make test`) now expects you to run `make` beforehand, which is more flexible for the user. This patch also reduces clutter by properly excluding unwanted files and reduces the number of explicit exlusion regexes that are required. Gcov reports are still confusing and report very low branch coverage (which is picked up by Codecov, unfortunately), but the llvm-cov reports are nice and clean now.
2021-09-27 08:13:30 -04:00
set(oneValueArgs NAME SOURCES_ROOT PROF_FILE)
set(multiValueArgs EXECUTABLE BINARY EXECUTABLE_ARGS DEPENDENCIES)
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
if(XCRUN_PATH)
set(LLVM_COV_PATH ${XCRUN_PATH} llvm-cov)
set(LLVM_PROFDATA_PATH ${XCRUN_PATH} llvm-profdata)
else()
if(NOT LLVM_COV_PATH)
message(FATAL_ERROR "llvm-cov not found! Aborting...")
endif() # NOT LLVM_COV_PATH
if(NOT LLVM_PROFDATA_PATH)
message(FATAL_ERROR "llvm-profdata not found! Aborting...")
endif() # NOT LLVM_PROFDATA_PATH
endif() # XCRUN_PATH
set(LLVM_PROFILE_DIR ${PROJECT_BINARY_DIR}/llvm_profile)
file(REMOVE_RECURSE ${LLVM_PROFILE_DIR})
set(COV_EXCLUDES "")
foreach(EXCLUDE ${COVERAGE_EXCLUDES})
list(APPEND COV_EXCLUDES "-ignore-filename-regex=${EXCLUDE}")
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
endforeach()
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
list(GET Coverage_BINARY 0 COV_BINARY)
if(Coverage_BINARY)
list(REMOVE_AT Coverage_BINARY 0)
foreach(BIN ${Coverage_BINARY})
list(APPEND COV_BINARY -object ${BIN})
endforeach()
endif()
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
add_custom_target(${Coverage_NAME}
Clean up code coverage reporting. CTest is now run directly and `make coverage` (like `make test`) now expects you to run `make` beforehand, which is more flexible for the user. This patch also reduces clutter by properly excluding unwanted files and reduces the number of explicit exlusion regexes that are required. Gcov reports are still confusing and report very low branch coverage (which is picked up by Codecov, unfortunately), but the llvm-cov reports are nice and clean now.
2021-09-27 08:13:30 -04:00
COMMAND ${CMAKE_COMMAND} -E env LLVM_PROFILE_FILE=${LLVM_PROFILE_DIR}/profile-%p.profraw ctest -C $<CONFIG> $$ARGS
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
COMMAND ${LLVM_PROFDATA_PATH} merge -sparse ${LLVM_PROFILE_DIR}/* -o coverage.profdata
WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
DEPENDS ${Coverage_DEPENDENCIES})
if("html" IN_LIST CMAKE_COVERAGE_FORMAT)
add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
COMMAND ${LLVM_COV_PATH} show -instr-profile=coverage.profdata ${COV_BINARY}
Clean up code coverage reporting. CTest is now run directly and `make coverage` (like `make test`) now expects you to run `make` beforehand, which is more flexible for the user. This patch also reduces clutter by properly excluding unwanted files and reduces the number of explicit exlusion regexes that are required. Gcov reports are still confusing and report very low branch coverage (which is picked up by Codecov, unfortunately), but the llvm-cov reports are nice and clean now.
2021-09-27 08:13:30 -04:00
--format=html --output-dir=${Coverage_NAME}-html ${COV_EXCLUDES} ${Coverage_SOURCES_ROOT}
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
COMMENT "Running llvm-cov to produce HTML code coverage report ${Coverage_NAME}-html")
endif()
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
Clean up code coverage reporting. CTest is now run directly and `make coverage` (like `make test`) now expects you to run `make` beforehand, which is more flexible for the user. This patch also reduces clutter by properly excluding unwanted files and reduces the number of explicit exlusion regexes that are required. Gcov reports are still confusing and report very low branch coverage (which is picked up by Codecov, unfortunately), but the llvm-cov reports are nice and clean now.
2021-09-27 08:13:30 -04:00
if("xml" IN_LIST CMAKE_COVERAGE_FORMAT)
message(WARNING "XML coverage report format not supported for llvm-cov")
endif()
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
if("txt" IN_LIST CMAKE_COVERAGE_FORMAT)
add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
COMMAND ${LLVM_COV_PATH} show -instr-profile=coverage.profdata ${COV_BINARY}
Clean up code coverage reporting. CTest is now run directly and `make coverage` (like `make test`) now expects you to run `make` beforehand, which is more flexible for the user. This patch also reduces clutter by properly excluding unwanted files and reduces the number of explicit exlusion regexes that are required. Gcov reports are still confusing and report very low branch coverage (which is picked up by Codecov, unfortunately), but the llvm-cov reports are nice and clean now.
2021-09-27 08:13:30 -04:00
--format=text ${COV_EXCLUDES} ${Coverage_SOURCES_ROOT} > ${Coverage_NAME}.txt
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
COMMENT "Running llvm-cov to produce TXT code coverage report ${Coverage_NAME}.txt.")
endif()
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
endfunction() # SETUP_TARGET_FOR_COVERAGE_LLVM
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
function(APPEND_COVERAGE_COMPILER_FLAGS)
Fix tests on macOS and update coverage config (#6945) Simplifies coverage generation and uses llvm-cov instead of gcov if compiler is clang.
2021-09-26 06:35:42 -04:00
message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}")
Update and fix test coverage report generation Generation of unit test coverage reports used to be quite complicated and required a lot of different settings, including a custom CMake build type. This patch updates the coverage CMake module to only require -DWITH_COVERAGE=ON to be set on a normal Debug build in order to create a coverage target. This patch also moves away from lcov in favor of gcovr, since lcov appears to be broken in GCC 8. However, the routines for generating lcov reports still exist, so provided lcov receives updates and there is sufficient reason to switch back, it is easy to do so.
2018-09-29 08:55:33 -04:00
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
Minor documentation and script cleanups (#6868) * Remove mention of no longer used IRC network Channels exist on matrix, and on libera.chat now. * Correctly match only files with .png extension The current search would match files such as 'createpng'. * Fix comparison in script The result was always false, due to comparing a literal string instead of a variable. * Use correct license files from upstream Correct license files obtained from: https://www.gnu.org/licenses/old-licenses/gpl-2.0.txt https://www.gnu.org/licenses/gpl-3.0.txt https://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt https://www.gnu.org/licenses/lgpl-3.0.txt * Refresh several shell scripts This fixes several shellcheck warnings, as well as makes the code more robust and have consistent codestyle between all the files. * Trim excess whitespace
2021-09-21 00:17:46 -04:00
endfunction() # APPEND_COVERAGE_COMPILER_FLAGS
Reference in New Issue Copy Permalink