From 160527b86ea04a93873706ccbe1fec8df03bf7d6 2017-06-05 08:11:28 From: Alexandre Leroux Date: 2017-06-05 08:11:28 Subject: [PATCH] commit temp --- diff --git a/app/CMakeLists.txt b/app/CMakeLists.txt index 4852e74..b86137b 100644 --- a/app/CMakeLists.txt +++ b/app/CMakeLists.txt @@ -82,6 +82,7 @@ SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES) # Compile the tests # IF(BUILD_TESTS) + INCLUDE_DIRECTORIES(${SOURCES_DIR}) FILE (GLOB_RECURSE TESTS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/Test*.cpp) FILE (GLOB_RECURSE TESTS_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/Test*.h) @@ -89,7 +90,7 @@ IF(BUILD_TESTS) FOREACH( testFile ${TESTS_SOURCES} ) GET_FILENAME_COMPONENT( testDirectory ${testFile} DIRECTORY ) - GET_FILENAME_COMPONENT( testName ${testFile} NAME_WE ) + GET_FILENAME_COMPONENT( testName ${testFile} NAME_WE ) # Add to the list of sources files all the sources in the same # directory that aren't another test @@ -101,7 +102,7 @@ IF(BUILD_TESTS) LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS}) ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources}) - TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} ) + TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} gcov) qt5_use_modules(${testName} Test) ADD_TEST( NAME ${testName} COMMAND ${testName} ) @@ -112,6 +113,7 @@ IF(BUILD_TESTS) LIST(APPEND testFilesToFormat ${TESTS_SOURCES}) LIST(APPEND testFilesToFormat ${TESTS_HEADERS}) LIST(APPEND FORMATTING_INPUT_FILES ${testFilesToFormat}) + SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES) ENDIF(BUILD_TESTS) diff --git a/cmake/sciqlop_applications.cmake b/cmake/sciqlop_applications.cmake index 9b41ac3..c98a731 100644 --- a/cmake/sciqlop_applications.cmake +++ b/cmake/sciqlop_applications.cmake @@ -13,6 +13,8 @@ ELSE() SET (CONFIG_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/dist/${CMAKE_BUILD_TYPE}) ENDIF() +INCLUDE ("cmake/sciqlop_code_coverage.cmake") + # # Compile the diffents modules # @@ -36,7 +38,7 @@ FILE(COPY ${QTLOGGING_INI_FILE} DESTINATION ${CONFIG_OUTPUT_PATH}) # # Vera++ exclusion files LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/formatting/vera-exclusions/exclusions.txt) -SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES) +#SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES) INCLUDE ("cmake/sciqlop_formatting.cmake") # diff --git a/cmake/sciqlop_code_coverage.cmake b/cmake/sciqlop_code_coverage.cmake new file mode 100644 index 0000000..d300508 --- /dev/null +++ b/cmake/sciqlop_code_coverage.cmake @@ -0,0 +1,249 @@ +# Copyright (c) 2012 - 2017, Lars Bilke +# 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. +# +# CHANGES: +# +# 2012-01-31, Lars Bilke +# - Enable Code Coverage +# +# 2013-09-17, Joakim Söderberg +# - Added support for Clang. +# - 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: +# +# 1. Copy this file into your cmake modules path. +# +# 2. Add the following line to your CMakeLists.txt: +# include(CodeCoverage) +# +# 3. Append necessary compiler flags: +# APPEND_COVERAGE_COMPILER_FLAGS() +# +# 4. If you need to exclude additional directories from the report, specify them +# using the COVERAGE_EXCLUDES variable before calling SETUP_TARGET_FOR_COVERAGE. +# Example: +# set(COVERAGE_EXCLUDES 'dir1/*' 'dir2/*') +# +# 5. Use the function SETUP_TARGET_FOR_COVERAGE to create a custom make target +# which runs your test executable and produces a lcov code coverage report: +# Example: +# SETUP_TARGET_FOR_COVERAGE( +# 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. +# ) +# +# 6. Build a Debug build: +# cmake -DCMAKE_BUILD_TYPE=Debug .. +# make +# make my_coverage_target +# + +include(CMakeParseArguments) + +# Check prereqs +find_program( GCOV_PATH gcov ) +find_program( LCOV_PATH lcov ) +find_program( GENHTML_PATH genhtml ) +find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test) +find_program( SIMPLE_PYTHON_EXECUTABLE python ) + +if(NOT GCOV_PATH) + message(FATAL_ERROR "gcov not found! Aborting...") +endif() # NOT GCOV_PATH + +if("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang") + if("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3) + message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...") + endif() +elseif(NOT CMAKE_COMPILER_IS_GNUCXX) + message(FATAL_ERROR "Compiler is not GNU gcc! Aborting...") +endif() + +set(COVERAGE_COMPILER_FLAGS "-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." + FORCE ) +set(CMAKE_C_FLAGS_COVERAGE + ${COVERAGE_COMPILER_FLAGS} + CACHE STRING "Flags used by the C compiler during coverage builds." + FORCE ) +set(CMAKE_EXE_LINKER_FLAGS_COVERAGE + "" + CACHE STRING "Flags used for linking binaries during coverage builds." + FORCE ) +set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE + "" + CACHE STRING "Flags used by the shared libraries linker during coverage builds." + FORCE ) +mark_as_advanced( + CMAKE_CXX_FLAGS_COVERAGE + CMAKE_C_FLAGS_COVERAGE + CMAKE_EXE_LINKER_FLAGS_COVERAGE + CMAKE_SHARED_LINKER_FLAGS_COVERAGE ) + +if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug") + message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading") +endif() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug" + +message( CMAKE_BUILD_TYPE : ${CMAKE_BUILD_TYPE}) +if(CMAKE_COMPILER_IS_GNUCXX) + link_libraries(gcov) +else() + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage") +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. +# +# SETUP_TARGET_FOR_COVERAGE( +# NAME testrunner_coverage # New target name +# EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR +# DEPENDENCIES testrunner # Dependencies to build first +# ) +function(SETUP_TARGET_FOR_COVERAGE) + + set(options NONE) + set(oneValueArgs NAME TARGET GCNO) + set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES) + cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + if(NOT LCOV_PATH) +# message(FATAL_ERROR "lcov not found! Aborting...") + endif() # NOT LCOV_PATH + + if(NOT GENHTML_PATH) +# message(FATAL_ERROR "genhtml not found! Aborting...") + endif() # NOT GENHTML_PATH + message("Coverage target: " ${Coverage_TARGET}) + message("Coverage name: " ${Coverage_NAME}) + message("Coverage exe: " ${Coverage_EXECUTABLE}) + message("Coverage gcno: " ${Coverage_GCNO}) + + # Setup target + add_custom_target(${Coverage_TARGET} + + # Cleanup lcov +# COMMAND ${LCOV_PATH} --directory . --zerocounters + + # Run tests + COMMAND ${Coverage_EXECUTABLE} + # Capturing lcov counters and generating report + COMMAND gcov ${Coverage_NAME} --object-file ${Coverage_GCNO} + + # COMMAND ${LCOV_PATH} --directory . --capture --output-file ${Coverage_NAME}.info +# COMMAND ${LCOV_PATH} --remove ${Coverage_NAME}.info ${COVERAGE_EXCLUDES} --output-file ${Coverage_NAME}.info.cleaned +# COMMAND ${GENHTML_PATH} -o ${Coverage_NAME} ${Coverage_NAME}.info.cleaned +# COMMAND ${CMAKE_COMMAND} -E remove ${Coverage_NAME}.info ${Coverage_NAME}.info.cleaned + + WORKING_DIRECTORY ${PROJECT_BINARY_DIR} + DEPENDS ${Coverage_DEPENDENCIES} + COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report." + ) + + # Show info where to find the report +# message("Nome de la target ${Coverage_TARGET}") +# add_custom_command(TARGET ${Coverage_TARGET} POST_BUILD +# COMMAND ; +# COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report." +# ) + +endfunction() # SETUP_TARGET_FOR_COVERAGE + +# 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_COBERTURA( +# 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_COBERTURA) + + 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(COBERTURA_EXCLUDES "") + foreach(EXCLUDE ${COVERAGE_EXCLUDES}) + set(COBERTURA_EXCLUDES "-e ${EXCLUDE} ${COBERTURA_EXCLUDES}") + endforeach() + + add_custom_target(${Coverage_NAME} + + # Run tests + ${Coverage_EXECUTABLE} + + # Running gcovr + COMMAND ${GCOVR_PATH} -x -r ${CMAKE_SOURCE_DIR} ${COBERTURA_EXCLUDES} + -o ${Coverage_NAME}.xml + WORKING_DIRECTORY ${PROJECT_BINARY_DIR} + DEPENDS ${Coverage_DEPENDENCIES} + COMMENT "Running gcovr to produce Cobertura code coverage report." + ) + + # Show info where to find the report + add_custom_command(TARGET ${Coverage_NAME} POST_BUILD + COMMAND ; + COMMENT "Cobertura code coverage report saved in ${Coverage_NAME}.xml." + ) + +endfunction() # SETUP_TARGET_FOR_COVERAGE_COBERTURA + +function(APPEND_COVERAGE_COMPILER_FLAGS) + set(CMAKE_C_FLAGS "${CMAKE_CXX_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 diff --git a/cmake/sciqlop_params.cmake b/cmake/sciqlop_params.cmake index 1d9232e..237ae58 100644 --- a/cmake/sciqlop_params.cmake +++ b/cmake/sciqlop_params.cmake @@ -7,11 +7,9 @@ #SET(SCIQLOP_BUILD_TYPE "Release" CACHE STRING "Choose to compile in Debug or Release mode") IF(CMAKE_BUILD_TYPE MATCHES "Debug") - SET (CMAKE_BUILD_TYPE "Debug") SET (DEBUG_SUFFIX "d") ELSE() MESSAGE (STATUS "Build in Release") - SET (SCIQLOP_BUILD_TYPE "Release") SET (DEBUG_SUFFIX "") ENDIF() diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt index 2253ebd..dd73a25 100644 --- a/core/CMakeLists.txt +++ b/core/CMakeLists.txt @@ -78,20 +78,27 @@ IF(BUILD_TESTS) FILE (GLOB currentTestSources ${testDirectory}/*.c ${testDirectory}/*.cpp - ${testDirectory}/*.h) - LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES}) - # LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS}) + ${testDirectory}/*.h) + LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES}) + # LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS}) - ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources}) - set_property(TARGET ${testName} PROPERTY CXX_STANDARD 14) - set_property(TARGET ${testName} PROPERTY CXX_STANDARD_REQUIRED ON) - TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} ) - qt5_use_modules(${testName} Test) + ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources}) + set_property(TARGET ${testName} PROPERTY CXX_STANDARD 14) + set_property(TARGET ${testName} PROPERTY CXX_STANDARD_REQUIRED ON) + TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} ) + qt5_use_modules(${testName} Test) - ADD_TEST( NAME ${testName} COMMAND ${testName} ) + ADD_TEST( NAME ${testName} COMMAND ${testDirectory} ) + set({testGCNO} ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${testName}.dir/tests/) + +# MESSAGE("Current build did :" ${testGCNO}) + MESSAGE("Current build did :" ${CMAKE_FILES_DIRECTORY}) + MESSAGE("Current build did :" ${currentTestSources}) SCIQLOP_COPY_TO_TARGET(RUNTIME ${testName} ${EXTERN_SHARED_LIBRARIES}) - ENDFOREACH( testFile ) + set(Coverage_NAME ${testName}) + SETUP_TARGET_FOR_COVERAGE(TARGET ${testName}_coverage NAME ${testFile} EXECUTABLE ${testName}) + ENDFOREACH( testFile ) LIST(APPEND testFilesToFormat ${TESTS_SOURCES}) LIST(APPEND testFilesToFormat ${TESTS_HEADERS})