Git-Mirrors/keepassxc
1
0
Fork 0
mirror of https://github.com/keepassxreboot/keepassxc.git synced 2024-12-24 23:09:44 -05:00
Code Issues Packages Projects Releases Wiki Activity

Update and fix test coverage report generation

Browse Source 
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.
This commit is contained in:
Janek Bevendorff 2018-09-29 14:55:33 +02:00
parent b8d2d5d877
commit 18b22834c1
3 changed files with 232 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
CMakeLists.txt
View File

@ -204,12 +204,6 @@ endif()
if(CMAKE_COMPILER_IS_GNUCXX) if(CMAKE_COMPILER_IS_GNUCXX)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wcast-align") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wcast-align")
if(WITH_COVERAGE)
# Include code coverage, use with -DCMAKE_BUILD_TYPE=Coverage
include(CodeCoverage)
setup_target_for_coverage(kp_coverage "make test" coverage)
endif()
endif() endif()
if(CMAKE_COMPILER_IS_GNUCC) if(CMAKE_COMPILER_IS_GNUCC)
@ -291,6 +285,21 @@ if(WITH_TESTS)
enable_testing() enable_testing()
endif(WITH_TESTS) endif(WITH_TESTS)
if(WITH_COVERAGE)
# Include code coverage, use with -DCMAKE_BUILD_TYPE=Debug
include(CodeCoverage)
set(COVERAGE_GCOVR_EXCLUDES
"\\(.+/\\)?tests/.\\*"
".\\*/moc_\\[^/\\]+\\.cpp"
".\\*/ui_\\[^/\\]+\\.h"
"\\(.+/\\)?zxcvbn/.\\*")
append_coverage_compiler_flags()
setup_target_for_coverage_gcovr_html(
NAME coverage
EXECUTABLE $(MAKE) && $(MAKE) test
)
endif()
include(CLangFormat) include(CLangFormat)
if(UNIX AND NOT APPLE) if(UNIX AND NOT APPLE)

298
cmake/CodeCoverage.cmake
View File

@ -1,4 +1,4 @@
# Copyright (c) 2012 - 2015, Lars Bilke # Copyright (c) 2012 - 2017, Lars Bilke
# All rights reserved. # All rights reserved.
# #
# Redistribution and use in source and binary forms, with or without modification, # Redistribution and use in source and binary forms, with or without modification,
@ -26,7 +26,7 @@
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# #
# # CHANGES:
# #
# 2012-01-31, Lars Bilke # 2012-01-31, Lars Bilke
# - Enable Code Coverage # - Enable Code Coverage
@ -35,167 +35,269 @@
# - Added support for Clang. # - Added support for Clang.
# - Some additional usage instructions. # - Some additional usage instructions.
# #
# 2016-02-03, Lars Bilke
# - Refactored functions to use named parameters
#
# 2017-06-02, Lars Bilke
# - Merged with modified version from github.com/ufz/ogs
#
#
# USAGE: # USAGE:
# 0. (Mac only) If you use Xcode 5.1 make sure to patch geninfo as described here:
# http://stackoverflow.com/a/22404544/80480
# #
# 1. Copy this file into your cmake modules path. # 1. Copy this file into your cmake modules path.
# #
# 2. Add the following line to your CMakeLists.txt: # 2. Add the following line to your CMakeLists.txt:
# INCLUDE(CodeCoverage) # include(CodeCoverage)
# #
# 3. Set compiler flags to turn off optimization and enable coverage: # 3. Append necessary compiler flags:
# SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage") # APPEND_COVERAGE_COMPILER_FLAGS()
# SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
# #
# 3. Use the function SETUP_TARGET_FOR_COVERAGE to create a custom make target # 4. If you need to exclude additional directories from the report, specify them
# which runs your test executable and produces a lcov code coverage report: # using the COVERAGE_LCOV_EXCLUDES variable before calling SETUP_TARGET_FOR_COVERAGE_LCOV.
# Example: # Example:
# SETUP_TARGET_FOR_COVERAGE( # set(COVERAGE_LCOV_EXCLUDES 'dir1/*' 'dir2/*')
# my_coverage_target # Name for custom target.
# test_driver # Name of the test driver executable that runs the tests.
# # NOTE! This should always have a ZERO as exit code
# # otherwise the coverage generation will not complete.
# coverage # Name of output directory.
# )
# #
# 4. Build a Debug build: # 5. Use the functions described below to create a custom make target which
# runs your test executable and produces a code coverage report.
#
# 6. Build a Debug build:
# cmake -DCMAKE_BUILD_TYPE=Debug .. # cmake -DCMAKE_BUILD_TYPE=Debug ..
# make # make
# make my_coverage_target # make my_coverage_target
# #
#
include(CMakeParseArguments)
# Check prereqs # Check prereqs
FIND_PROGRAM( GCOV_PATH gcov ) find_program( GCOV_PATH gcov )
FIND_PROGRAM( LCOV_PATH lcov ) find_program( LCOV_PATH NAMES lcov lcov.bat lcov.exe lcov.perl)
FIND_PROGRAM( GENHTML_PATH genhtml ) find_program( GENHTML_PATH NAMES genhtml genhtml.perl genhtml.bat )
FIND_PROGRAM( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/tests) find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
find_program( SIMPLE_PYTHON_EXECUTABLE python )
IF(NOT GCOV_PATH) if(NOT GCOV_PATH)
MESSAGE(FATAL_ERROR "gcov not found! Aborting...") message(FATAL_ERROR "gcov not found! Aborting...")
ENDIF() # NOT GCOV_PATH endif() # NOT GCOV_PATH
IF("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang") if("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
IF("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3) if("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3)
MESSAGE(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...") message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
ENDIF() endif()
ELSEIF(NOT CMAKE_COMPILER_IS_GNUCXX) elseif(NOT CMAKE_COMPILER_IS_GNUCXX)
MESSAGE(FATAL_ERROR "Compiler is not GNU gcc! Aborting...") message(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
ENDIF() # CHECK VALID COMPILER endif()
SET(CMAKE_CXX_FLAGS_COVERAGE set(COVERAGE_COMPILER_FLAGS "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
"-g -O0 --coverage -fprofile-arcs -ftest-coverage" CACHE INTERNAL "")
set(CMAKE_CXX_FLAGS_COVERAGE
${COVERAGE_COMPILER_FLAGS}
CACHE STRING "Flags used by the C++ compiler during coverage builds." CACHE STRING "Flags used by the C++ compiler during coverage builds."
FORCE ) FORCE )
SET(CMAKE_C_FLAGS_COVERAGE set(CMAKE_C_FLAGS_COVERAGE
"-g -O0 --coverage -fprofile-arcs -ftest-coverage" ${COVERAGE_COMPILER_FLAGS}
CACHE STRING "Flags used by the C compiler during coverage builds." CACHE STRING "Flags used by the C compiler during coverage builds."
FORCE ) FORCE )
SET(CMAKE_EXE_LINKER_FLAGS_COVERAGE set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
"" ""
CACHE STRING "Flags used for linking binaries during coverage builds." CACHE STRING "Flags used for linking binaries during coverage builds."
FORCE ) FORCE )
SET(CMAKE_SHARED_LINKER_FLAGS_COVERAGE set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
"" ""
CACHE STRING "Flags used by the shared libraries linker during coverage builds." CACHE STRING "Flags used by the shared libraries linker during coverage builds."
FORCE ) FORCE )
MARK_AS_ADVANCED( mark_as_advanced(
CMAKE_CXX_FLAGS_COVERAGE CMAKE_CXX_FLAGS_COVERAGE
CMAKE_C_FLAGS_COVERAGE CMAKE_C_FLAGS_COVERAGE
CMAKE_EXE_LINKER_FLAGS_COVERAGE CMAKE_EXE_LINKER_FLAGS_COVERAGE
CMAKE_SHARED_LINKER_FLAGS_COVERAGE ) CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
IF ( NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "Coverage")) if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
MESSAGE( WARNING "Code coverage results with an optimized (non-Debug) build may be misleading" ) message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
ENDIF() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug" endif() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug"
if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
link_libraries(gcov)
else()
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
endif()
# Param _targetname The name of new the custom make target # Defines a target for running and collection code coverage information
# Param _testrunner The name of the target which runs the tests. # Builds dependencies, runs the given executable and outputs reports.
# MUST return ZERO always, even on errors. # NOTE! The executable should always have a ZERO as exit code otherwise
# If not, no coverage report will be created! # the coverage generation will not complete.
# Param _outputname lcov output is generated as _outputname.info #
# HTML report is generated in _outputname/index.html # SETUP_TARGET_FOR_COVERAGE_LCOV(
# Optional fourth parameter is passed as arguments to _testrunner # NAME testrunner_coverage # New target name
# Pass them in list form, e.g.: "-j;2" for -j 2 # EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _testrunner _outputname) # DEPENDENCIES testrunner # Dependencies to build first
# )
function(SETUP_TARGET_FOR_COVERAGE_LCOV)
IF(NOT LCOV_PATH) set(options NONE)
MESSAGE(FATAL_ERROR "lcov not found! Aborting...") set(oneValueArgs NAME)
ENDIF() # NOT LCOV_PATH set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
IF(NOT GENHTML_PATH) if(NOT LCOV_PATH)
MESSAGE(FATAL_ERROR "genhtml not found! Aborting...") message(FATAL_ERROR "lcov not found! Aborting...")
ENDIF() # NOT GENHTML_PATH endif() # NOT LCOV_PATH
SET(coverage_info "${CMAKE_BINARY_DIR}/${_outputname}.info") if(NOT GENHTML_PATH)
IF(MINGW) message(FATAL_ERROR "genhtml not found! Aborting...")
# Replace C:/ with /C for MINGW endif() # NOT GENHTML_PATH
STRING(REGEX REPLACE "^([a-zA-Z]):" "/\\1" coverage_info ${coverage_info})
ENDIF()
SET(coverage_cleaned "${coverage_info}.cleaned")
SEPARATE_ARGUMENTS(test_command UNIX_COMMAND "${_testrunner}")
# Setup target # Setup target
ADD_CUSTOM_TARGET(${_targetname} add_custom_target(${Coverage_NAME}
# Cleanup lcov # Cleanup lcov
${LCOV_PATH} --directory . --zerocounters COMMAND ${LCOV_PATH} --gcov-tool ${GCOV_PATH} -directory . --zerocounters
# Create baseline to make sure untouched files show up in the report
COMMAND ${LCOV_PATH} --gcov-tool ${GCOV_PATH} -c -i -d . -o ${Coverage_NAME}.base
# Run tests # Run tests
COMMAND ${test_command} ${ARGV3} COMMAND ${Coverage_EXECUTABLE}
# Capturing lcov counters and generating report # Capturing lcov counters and generating report
COMMAND ${LCOV_PATH} --directory . --capture --output-file ${coverage_info} COMMAND ${LCOV_PATH} --gcov-tool ${GCOV_PATH} --directory . --capture --output-file ${Coverage_NAME}.info
COMMAND ${LCOV_PATH} --remove ${coverage_info} 'tests/*' '/usr/*' --output-file ${coverage_cleaned} # add baseline counters
COMMAND ${GENHTML_PATH} -o ${_outputname} ${coverage_cleaned} COMMAND ${LCOV_PATH} --gcov-tool ${GCOV_PATH} -a ${Coverage_NAME}.base -a ${Coverage_NAME}.info --output-file ${Coverage_NAME}.total
COMMAND ${CMAKE_COMMAND} -E remove ${coverage_info} ${coverage_cleaned} COMMAND ${LCOV_PATH} --gcov-tool ${GCOV_PATH} --remove ${Coverage_NAME}.total ${COVERAGE_LCOV_EXCLUDES} --output-file ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned
COMMAND ${GENHTML_PATH} -o ${Coverage_NAME} ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned
COMMAND ${CMAKE_COMMAND} -E remove ${Coverage_NAME}.base ${Coverage_NAME}.total ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned
WORKING_DIRECTORY ${CMAKE_BINARY_DIR} WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
DEPENDS ${Coverage_DEPENDENCIES}
COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report." COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
) )
# Show info where to find the report # Show where to find the lcov info report
ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
COMMAND ; COMMAND ;
COMMENT "Open ./${_outputname}/index.html in your browser to view the coverage report." COMMENT "Lcov code coverage info report saved in ${Coverage_NAME}.info."
) )
ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE # Show info where to find the report
add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
COMMAND ;
COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
)
# Param _targetname The name of new the custom make target endfunction() # SETUP_TARGET_FOR_COVERAGE_LCOV
# Param _testrunner The name of the target which runs the tests
# Param _outputname cobertura output is generated as _outputname.xml
# Optional fourth parameter is passed as arguments to _testrunner
# Pass them in list form, e.g.: "-j;2" for -j 2
FUNCTION(SETUP_TARGET_FOR_COVERAGE_COBERTURA _targetname _testrunner _outputname)
IF(NOT PYTHON_EXECUTABLE) # Defines a target for running and collection code coverage information
MESSAGE(FATAL_ERROR "Python not found! Aborting...") # Builds dependencies, runs the given executable and outputs reports.
ENDIF() # NOT PYTHON_EXECUTABLE # NOTE! The executable should always have a ZERO as exit code otherwise
# the coverage generation will not complete.
#
# SETUP_TARGET_FOR_COVERAGE_GCOVR_XML(
# NAME ctest_coverage # New target name
# EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
# DEPENDENCIES executable_target # Dependencies to build first
# )
function(SETUP_TARGET_FOR_COVERAGE_GCOVR_XML)
IF(NOT GCOVR_PATH) set(options NONE)
MESSAGE(FATAL_ERROR "gcovr not found! Aborting...") set(oneValueArgs NAME)
ENDIF() # NOT GCOVR_PATH set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
ADD_CUSTOM_TARGET(${_targetname} if(NOT SIMPLE_PYTHON_EXECUTABLE)
message(FATAL_ERROR "python not found! Aborting...")
endif() # NOT SIMPLE_PYTHON_EXECUTABLE
if(NOT GCOVR_PATH)
message(FATAL_ERROR "gcovr not found! Aborting...")
endif() # NOT GCOVR_PATH
# Combine excludes to several -e arguments
set(GCOVR_EXCLUDES "")
foreach(EXCLUDE ${COVERAGE_GCOVR_EXCLUDES})
list(APPEND GCOVR_EXCLUDES "-e")
list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
endforeach()
add_custom_target(${Coverage_NAME}
# Run tests # Run tests
${_testrunner} ${ARGV3} ${Coverage_EXECUTABLE}
# Running gcovr # Running gcovr
COMMAND ${GCOVR_PATH} -x -r ${CMAKE_SOURCE_DIR} -e '${CMAKE_SOURCE_DIR}/tests/' -o ${_outputname}.xml COMMAND ${GCOVR_PATH} --xml
WORKING_DIRECTORY ${CMAKE_BINARY_DIR} -r ${PROJECT_SOURCE_DIR} ${GCOVR_EXCLUDES}
--object-directory=${PROJECT_BINARY_DIR}
-o ${Coverage_NAME}.xml
WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
DEPENDS ${Coverage_DEPENDENCIES}
COMMENT "Running gcovr to produce Cobertura code coverage report." COMMENT "Running gcovr to produce Cobertura code coverage report."
) )
# Show info where to find the report # Show info where to find the report
ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
COMMAND ; COMMAND ;
COMMENT "Cobertura code coverage report saved in ${_outputname}.xml." COMMENT "Cobertura code coverage report saved in ${Coverage_NAME}.xml."
) )
ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE_COBERTURA endfunction() # SETUP_TARGET_FOR_COVERAGE_GCOVR_XML
# 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.
#
# SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML(
# NAME ctest_coverage # New target name
# EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
# DEPENDENCIES executable_target # Dependencies to build first
# )
function(SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML)
set(options NONE)
set(oneValueArgs NAME)
set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
if(NOT SIMPLE_PYTHON_EXECUTABLE)
message(FATAL_ERROR "python not found! Aborting...")
endif() # NOT SIMPLE_PYTHON_EXECUTABLE
if(NOT GCOVR_PATH)
message(FATAL_ERROR "gcovr not found! Aborting...")
endif() # NOT GCOVR_PATH
# Combine excludes to several -e arguments
set(GCOVR_EXCLUDES "")
foreach(EXCLUDE ${COVERAGE_GCOVR_EXCLUDES})
list(APPEND GCOVR_EXCLUDES "-e")
list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
endforeach()
add_custom_target(${Coverage_NAME}
# Run tests
${Coverage_EXECUTABLE}
# Create folder
COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/${Coverage_NAME}
# Running gcovr
COMMAND ${GCOVR_PATH} --html --html-details
-r ${PROJECT_SOURCE_DIR} ${GCOVR_EXCLUDES}
--object-directory=${PROJECT_BINARY_DIR}
-o ${Coverage_NAME}/index.html
WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
DEPENDS ${Coverage_DEPENDENCIES}
COMMENT "Running gcovr to produce HTML code coverage report."
)
# Show info where to find the report
add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
COMMAND ;
COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
)
endfunction() # SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML
function(APPEND_COVERAGE_COMPILER_FLAGS)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}")
endfunction() # APPEND_COVERAGE_COMPILER_FLAGS

2
src/crypto/Crypto.cpp
View File

@ -50,7 +50,7 @@ bool Crypto::init()
// has to be set before testing Crypto classes // has to be set before testing Crypto classes
m_initalized = true; m_initalized = true;
if (!selfTest()) { if (!backendSelfTest() || !selfTest()) {
m_initalized = false; m_initalized = false;
return false; return false;
} }