GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r43:0126f33b354b

Merge pull request from SCIQLOP-Initialisation feature/Gcov...

perrinel -

r43:0126f33b354b

parent child

Context file:

r43:0126f33b354b

cmake/sciqlop_code_coverage.cmake created 644 +191 0

@@ -0,0 +1,191
	1	# Copyright (c) 2012 - 2017, Lars Bilke
	2	# All rights reserved.
	3	#
	4	# Redistribution and use in source and binary forms, with or without modification,
	5	# are permitted provided that the following conditions are met:
	6	#
	7	# 1. Redistributions of source code must retain the above copyright notice, this
	8	# list of conditions and the following disclaimer.
	9	#
	10	# 2. Redistributions in binary form must reproduce the above copyright notice,
	11	# this list of conditions and the following disclaimer in the documentation
	12	# and/or other materials provided with the distribution.
	13	#
	14	# 3. Neither the name of the copyright holder nor the names of its contributors
	15	# may be used to endorse or promote products derived from this software without
	16	# specific prior written permission.
	17	#
	18	# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
	19	# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	20	# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	21	# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
	22	# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	23	# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	24	# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
	25	# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	26	# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
	27	# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	28	#
	29	# CHANGES:
	30	#
	31	# 2012-01-31, Lars Bilke
	32	# - Enable Code Coverage
	33	#
	34	# 2013-09-17, Joakim Söderberg
	35	# - Added support for Clang.
	36	# - Some additional usage instructions.
	37	#
	38	# 2016-02-03, Lars Bilke
	39	# - Refactored functions to use named parameters
	40	#
	41	# 2017-06-02, Lars Bilke
	42	# - Merged with modified version from github.com/ufz/ogs
	43	#
	44	#
	45	# USAGE:
	46	#
	47	# 1. Copy this file into your cmake modules path.
	48	#
	49	# 2. Add the following line to your CMakeLists.txt:
	50	# include(CodeCoverage)
	51	#
	52	# 3. Append necessary compiler flags:
	53	# APPEND_COVERAGE_COMPILER_FLAGS()
	54	#
	55	# 4. If you need to exclude additional directories from the report, specify them
	56	# using the COVERAGE_EXCLUDES variable before calling SETUP_TARGET_FOR_COVERAGE.
	57	# Example:
	58	# set(COVERAGE_EXCLUDES 'dir1/' 'dir2/')
	59	#
	60	# 5. Use the function SETUP_TARGET_FOR_COVERAGE to create a custom make target
	61	# which runs your test executable and produces a lcov code coverage report:
	62	# Example:
	63	# SETUP_TARGET_FOR_COVERAGE(
	64	# my_coverage_target # Name for custom target.
	65	# test_driver # Name of the test driver executable that runs the tests.
	66	# # NOTE! This should always have a ZERO as exit code
	67	# # otherwise the coverage generation will not complete.
	68	# coverage # Name of output directory.
	69	# )
	70	#
	71	# 6. Build a Debug build:
	72	# cmake -DCMAKE_BUILD_TYPE=Debug ..
	73	# make
	74	# make my_coverage_target
	75	#
	76
	77	include(CMakeParseArguments)
	78
	79	# Check prereqs
	80	find_program( GCOV_PATH gcov )
	81	find_program( LCOV_PATH lcov )
	82	find_program( GENHTML_PATH genhtml )
	83	find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
	84	find_program( SIMPLE_PYTHON_EXECUTABLE python )
	85
	86	if(NOT GCOV_PATH)
	87	message(FATAL_ERROR "gcov not found! Aborting...")
	88	endif() # NOT GCOV_PATH
	89
	90	if("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
	91	if("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3)
	92	message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
	93	endif()
	94	elseif(NOT CMAKE_COMPILER_IS_GNUCXX)
	95	message(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
	96	endif()
	97
	98	set(COVERAGE_COMPILER_FLAGS "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
	99	CACHE INTERNAL "")
	100
	101	set(CMAKE_CXX_FLAGS_COVERAGE
	102	${COVERAGE_COMPILER_FLAGS}
	103	CACHE STRING "Flags used by the C++ compiler during coverage builds."
	104	FORCE )
	105	set(CMAKE_C_FLAGS_COVERAGE
	106	${COVERAGE_COMPILER_FLAGS}
	107	CACHE STRING "Flags used by the C compiler during coverage builds."
	108	FORCE )
	109	set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
	110	""
	111	CACHE STRING "Flags used for linking binaries during coverage builds."
	112	FORCE )
	113	set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
	114	""
	115	CACHE STRING "Flags used by the shared libraries linker during coverage builds."
	116	FORCE )
	117	mark_as_advanced(
	118	CMAKE_CXX_FLAGS_COVERAGE
	119	CMAKE_C_FLAGS_COVERAGE
	120	CMAKE_EXE_LINKER_FLAGS_COVERAGE
	121	CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
	122
	123	if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
	124	message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
	125	endif() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug"
	126
	127	if(CMAKE_COMPILER_IS_GNUCXX)
	128	link_libraries(gcov)
	129	else()
	130	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
	131	endif()
	132
	133	# Defines a target for running and collection code coverage information
	134	# Builds dependencies, runs the given executable and outputs reports.
	135	# NOTE! The executable should always have a ZERO as exit code otherwise
	136	# the coverage generation will not complete.
	137	#
	138	# SETUP_TARGET_FOR_COVERAGE(
	139	# NAME testrunner_coverage # New target name
	140	# EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
	141	# DEPENDENCIES testrunner # Dependencies to build first
	142	# )
	143	function(SETUP_TARGET_FOR_COVERAGE)
	144
	145	set(options NONE)
	146	set(oneValueArgs NAME TARGET OUTPUT)
	147	set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
	148	cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
	149
	150	if(NOT LCOV_PATH)
	151	message(FATAL_ERROR "lcov not found! Aborting...")
	152	endif() # NOT LCOV_PATH
	153
	154	if(NOT GENHTML_PATH)
	155	message(FATAL_ERROR "genhtml not found! Aborting...")
	156	endif() # NOT GENHTML_PATH
	157
	158	# Setup target
	159	add_custom_target(${Coverage_TARGET}
	160
	161	# Cleanup lcov
	162	COMMAND ${LCOV_PATH} --directory . --zerocounters
	163
	164	# Run tests
	165	COMMAND ${Coverage_EXECUTABLE}
	166
	167	# Capturing lcov counters and generating report
	168	COMMAND ${LCOV_PATH} --directory . --capture --output-file ${Coverage_NAME}.info
	169	COMMAND ${LCOV_PATH} --remove ${Coverage_NAME}.info ${COVERAGE_EXCLUDES} --output-file ${Coverage_NAME}.info.cleaned
	170	COMMAND ${GENHTML_PATH} -o ${Coverage_OUTPUT} ${Coverage_NAME}.info.cleaned
	171	COMMAND ${CMAKE_COMMAND} -E remove ${Coverage_NAME}.info ${Coverage_NAME}.info.cleaned
	172
	173	WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
	174	DEPENDS ${Coverage_DEPENDENCIES}
	175	COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
	176	)
	177
	178	# Show info where to find the report
	179	# message("Nome de la target ${Coverage_TARGET}")
	180	# add_custom_command(TARGET ${Coverage_TARGET} POST_BUILD
	181	# COMMAND ;
	182	# COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
	183	# )
	184
	185	endfunction()
	186
	187	function(APPEND_COVERAGE_COMPILER_FLAGS)
	188	set(CMAKE_C_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
	189	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
	190	message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}")
	191	endfunction() # APPEND_COVERAGE_COMPILER_FLAGS

app/CMakeLists.txt +4 -2

             ## sciqlop - CMakeLists.txt
             SET(EXECUTABLE_NAME "sciqlop")
             SET(SOURCES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src/)
             SET(INCLUDE_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/include)
             SET(UI_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/src)
             SET(RES_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/resources)
             #
             # Find Qt modules
             #
             SCIQLOP_FIND_QT(Core Widgets)
             #
             # Find dependent libraries
             # ========================
             find_package(sciqlop-gui)
             SET(LIBRARIES ${SCIQLOP-GUI_LIBRARIES})
             SET(EXTERN_SHARED_LIBRARIES)
             INCLUDE_DIRECTORIES(${SCIQLOP-GUI_INCLUDE_DIR})
             # Add sqpcore to the list of libraries to use
             list(APPEND LIBRARIES ${SQPCORE_LIBRARY_NAME})
             # Include core directory
             include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../core/include")
             # Add dependent shared libraries
             list(APPEND SHARED_LIBRARIES ${SQPCORE_SHARED_LIBRARIES})
             # Retrieve the location of the dynamic library to copy it to the output path
             #get_property(sqpcoreLocation TARGET ${SQPCORE_LIBRARY_NAME} PROPERTY LOCATION)
             list(APPEND SHARED_LIBRARIES_FROM_TARGETS ${sqpcoreLocation})
             #
             # Compile the application
             #
             FILE (GLOB_RECURSE APPLICATION_SOURCES
             	${SOURCES_DIR}/*.c
             	${SOURCES_DIR}/*.cpp
             	${SOURCES_DIR}/*.h)
             # Headers files (.h)
             FILE (GLOB_RECURSE PROJECT_HEADERS ${INCLUDE_FOLDER}/*.h)
             # Ui files
             FILE (GLOB_RECURSE PROJECT_FORMS ${UI_FOLDER}/*.ui)
             # Resources files
             FILE (GLOB_RECURSE PROJECT_RESOURCES ${RES_FOLDER}/*.qrc)
             # Retrieve resources files
             FILE (GLOB_RECURSE APPLICATION_RESOURCES ${RES_FOLDER}/*.qrc)
             QT5_ADD_RESOURCES(RCC_HDRS ${APPLICATION_RESOURCES} )
             QT5_WRAP_UI(UIS_HDRS
              ${PROJECT_FORMS}
             )
             ADD_EXECUTABLE(${EXECUTABLE_NAME} ${APPLICATION_SOURCES} ${RCC_HDRS} ${UIS_HDRS})
             set_property(TARGET ${EXECUTABLE_NAME} PROPERTY CXX_STANDARD 14)
             set_property(TARGET ${EXECUTABLE_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
             target_link_libraries(${EXECUTABLE_NAME}
                 ${LIBRARIES})
             # Link with Qt5 modules
             qt5_use_modules(${EXECUTABLE_NAME} Core Widgets)
             # Add the files to the list of files to be analyzed
             LIST(APPEND CHECKSTYLE_INPUT_FILES ${APPLICATION_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_INPUT_FILES)
             # Vera++ exclusion files
             LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/vera-exclusions/exclusions.txt)
             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)
                     SET( TEST_LIBRARIES ${LIBRARIES})
             	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
             		FILE (GLOB currentTestSources
             			${testDirectory}/*.c
             			${testDirectory}/*.cpp
             			${testDirectory}/*.h)
             		LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
             		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} )
                             SCIQLOP_COPY_TO_TARGET(RUNTIME ${testName})
             	ENDFOREACH( testFile )
             	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)
             #
             # Set the files that must be formatted by clang-format.
             #
             LIST (APPEND FORMATTING_INPUT_FILES ${APPLICATION_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
             #
             # Set the directories that doxygen must browse to generate the
             # documentation.
             #
             # Source directories:
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/docs")
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_INPUT_DIRS)
             # Source directories to exclude from the documentation generation
             #LIST (APPEND DOXYGEN_EXCLUDE_PATTERNS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir/*")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_EXCLUDE_PATTERNS)
             #
             # Set the directories with the sources to analyze and propagate the
             # modification to the parent scope
             #
             # Source directories to analyze:
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_INPUT_DIRS)
             # Source directories to exclude from the analysis
             #LIST (APPEND ANALYSIS_EXCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_EXCLUDE_DIRS)

cmake/sciqlop_applications.cmake +7 -1

             #
             # Sciqlop_modules.cmake
             #
             # Set ouptut directories
             #
             SET (EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/dist/${CMAKE_BUILD_TYPE})
             SET (LIBRARY_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/dist/${CMAKE_BUILD_TYPE})
             IF (UNIX)
                 SET (CONFIG_OUTPUT_PATH $ENV{HOME}/.config/QtProject)
             ELSEIF(WIN32)
                 SET (CONFIG_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/dist/${CMAKE_BUILD_TYPE}/app/QtProject)
             ELSE()
                 SET (CONFIG_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/dist/${CMAKE_BUILD_TYPE})
             ENDIF()
+            INCLUDE ("cmake/sciqlop_code_coverage.cmake")
+            if(BUILD_TESTS)
+                APPEND_COVERAGE_COMPILER_FLAGS()
+            endif(BUILD_TESTS)
             #
             # Compile the diffents modules
             #
             set(sciqlop-core_DIR "${CMAKE_SOURCE_DIR}/core/cmake")
             set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${sciqlop-core_DIR}")
             ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/core")
             set(sciqlop-gui_DIR "${CMAKE_SOURCE_DIR}/gui/cmake")
             set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${sciqlop-gui_DIR}")
             ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/gui")
             ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/app")
             # LOGGER
             set(QTLOGGING_INI_FILE "${CMAKE_SOURCE_DIR}/config/QtProject/qtlogging.ini")
             FILE(COPY ${QTLOGGING_INI_FILE} DESTINATION ${CONFIG_OUTPUT_PATH})
             #
             # Code formatting
             #
             # 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")
             #
             # Documentation generation
             #
             INCLUDE ("cmake/sciqlop_doxygen.cmake")
             #
             # Source code analysis
             #
             INCLUDE ("cmake/sciqlop_code_analysis.cmake")
             INCLUDE ("cmake/sciqlop_code_cppcheck.cmake")

cmake/sciqlop_params.cmake 0 -2

             #
             # sciqlop_params : Define compilation parameters
             #
             # Debug or release
             #
             # As the "NMake Makefiles" forces by default the CMAKE_BUILD_TYPE variable to Debug, SCIQLOP_BUILD_TYPE variable is used to be sure that the debug mode is a user choice
             #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()
             #
             # Need to compile tests?
             #
             OPTION (BUILD_TESTS "Build the tests" OFF)
             ENABLE_TESTING(${BUILD_TESTS})
             #
             # Path to the folder for sciqlop's extern libraries.
             #
             # When looking for an external library in sciqlop, we look to the following
             # folders:
             #   - The specific folder for the library (generally of the form <LIBRARY>_ROOT_DIR
             #   - The global Sciqlop extern folder
             #   - The system folders.
             #
             # If a dependency is found in the global extern folder or a specific folder for
             # the library, then it is installed with the sciqlop libraries. If it is found
             # in the system folders, it is not. This behavior can be overriden with the
             # <LIBRARY>_COPY_SHARED_LIBRARIES flag.
             #
             set(SCIQLOP_EXTERN_FOLDER "${CMAKE_CURRENT_SOURCE_DIR}/extern"
                 CACHE PATH "Path to the folder for sciqlop's extern libraries")
             option(SCIQLOP_FORCE_UPDATE_EXT_ROOT_DIR "Force the <LIBRARY>_ROOT_DIR to be updated to the global sciqlop extern folder"
                 OFF)
             if (SCIQLOP_FORCE_UPDATE_EXT_ROOT_DIR)
                 set(libRootDirForceValue FORCE)
             else()
                 set(libRootDirForceValue)
             endif()
             #
             # Static or shared libraries
             #
             OPTION (BUILD_SHARED_LIBS "Build the shared libraries" ON)
             # Generate position independant code (-fPIC)
             SET(CMAKE_POSITION_INDEPENDENT_CODE TRUE)
             #
             # Configure installation directories
             #
             IF (UNIX)
                 SET(defaultBin "bin")
                 SET(defaultInc "include/sciqlop")
                 # 32 or 64 bits compiler
                 IF( CMAKE_SIZEOF_VOID_P EQUAL 8 )
                     SET(defaultLib "lib64/sciqlop")
                 ELSE()
                     SET(defaultLib "lib/sciqlop")
                 ENDIF()
                 SET(defaultDoc "share/docs/sciqlop")
             ELSE()
                 SET(defaultBin "bin")
                 SET(defaultInc "include/sciqlop")
                 SET(defaultLib "lib/sciqlop")
                 SET(defaultDoc "docs/sciqlop")
             ENDIF()
             SET(INSTALL_BINARY_DIR "${defaultBin}" CACHE STRING
                 "Installation directory for binaries")
             SET(INSTALL_LIBRARY_DIR "${defaultLib}" CACHE STRING
                 "Installation directory for libraries")
             SET(INSTALL_INCLUDE_DIR "${defaultInc}" CACHE STRING
                 "Installation directory for headers")
             SET(INSTALL_DOCUMENTATION_DIR "${defaultDoc}" CACHE STRING
                 "Installation directory for documentations")

core/CMakeLists.txt +12 -10

             ## core - CMakeLists.txt
             STRING(TOLOWER ${CMAKE_PROJECT_NAME} LIBRARY_PREFFIX)
             SET(SQPCORE_LIBRARY_NAME "${LIBRARY_PREFFIX}_core${DEBUG_SUFFIX}")
             SET(SOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src/")
             SET(INCLUDES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include/")
             # Include core directory
             include_directories("${INCLUDES_DIR}")
             # Set a variable to display a warning in the version files.
             SET(SCIQLOP_CMAKE_GENERATION_WARNING "DON'T CHANGE THIS FILE. AUTOGENERATED BY CMAKE.")
             # Generate the version file from the cmake version variables. The version
             # variables are defined in the cmake/sciqlop_version.cmake file.
             CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/resources/Version.h.in"
                     "${INCLUDES_DIR}/Version.h")
             CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/resources/Version.cpp.in"
             	"${SOURCES_DIR}/Version.cpp")
             #
             # Find Qt modules
             #
             SCIQLOP_FIND_QT(Core)
             #
             # Compile the library library
             #
             FILE (GLOB_RECURSE MODULE_SOURCES
                     ${INCLUDES_DIR}/*.h
                     ${SOURCES_DIR}/*.c
                     ${SOURCES_DIR}/*.cpp
             	${SOURCES_DIR}/*.h)
             ADD_LIBRARY(${SQPCORE_LIBRARY_NAME} ${MODULE_SOURCES})
             set_property(TARGET ${SQPCORE_LIBRARY_NAME} PROPERTY CXX_STANDARD 14)
             set_property(TARGET ${SQPCORE_LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
             TARGET_LINK_LIBRARIES(${SQPCORE_LIBRARY_NAME})
             qt5_use_modules(${SQPCORE_LIBRARY_NAME} Core)
             # From cmake documentation: http://www.cmake.org/cmake/help/v3.0/manual/cmake-buildsystem.7.html
             # Entries in the COMPILE_DEFINITIONS are prefixed with -D or /D and added to the compile line in an unspecified order.
             # The DEFINE_SYMBOL target property is also added as a compile definition as a special convenience case for SHARED and MODULE library targets
             IF(BUILD_SHARED_LIBS)
                     SET_TARGET_PROPERTIES(${SQPCORE_LIBRARY_NAME} PROPERTIES COMPILE_DEFINITIONS "SCIQLOP_EXPORT")
             ELSE()
                     TARGET_COMPILE_DEFINITIONS(${SQPCORE_LIBRARY_NAME} PUBLIC "SCIQLOP_STATIC_LIBRARIES")
             ENDIF()
             # Set the variable to parent scope so that the other projects can copy the
             # dependent shared libraries
             SCIQLOP_SET_TO_PARENT_SCOPE(SQPCORE_LIBRARY_NAME)
             # Copy extern shared libraries to the lib folder
             SCIQLOP_COPY_TO_TARGET(LIBRARY ${SQPCORE_LIBRARY_NAME} ${EXTERN_SHARED_LIBRARIES})
             # Add the files to the list of files to be analyzed
             LIST(APPEND CHECKSTYLE_INPUT_FILES ${MODULE_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_INPUT_FILES)
             # Vera++ exclusion files
             LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/vera-exclusions/exclusions.txt)
             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)
                     SET( TEST_LIBRARIES ${SQPCORE_LIBRARY_NAME})
             	FOREACH( testFile ${TESTS_SOURCES} )
             		GET_FILENAME_COMPONENT( testDirectory ${testFile} DIRECTORY )
             		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
             		FILE (GLOB currentTestSources
             			${testDirectory}/*.c
             			${testDirectory}/*.cpp
-            			${testDirectory}/*.h)
+                                    ${testDirectory}/*.h)
-                    LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
+                            LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
-                    # LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
+                            # LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
-            		ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources})
+                            ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources})
-                    set_property(TARGET ${testName} PROPERTY CXX_STANDARD 14)
+                            set_property(TARGET ${testName} PROPERTY CXX_STANDARD 14)
-                    set_property(TARGET ${testName} PROPERTY CXX_STANDARD_REQUIRED ON)
+                            set_property(TARGET ${testName} PROPERTY CXX_STANDARD_REQUIRED ON)
-            		TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} )
+                            TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} )
-            		qt5_use_modules(${testName} Test)
+                            qt5_use_modules(${testName} Test)
-            		ADD_TEST( NAME ${testName} COMMAND ${testName} )
+                            ADD_TEST( NAME ${testName} COMMAND ${testDirectory} )
                             SCIQLOP_COPY_TO_TARGET(RUNTIME ${testName} ${EXTERN_SHARED_LIBRARIES})
-            	ENDFOREACH( testFile )
+                            set(Coverage_NAME ${testName})
+                            SETUP_TARGET_FOR_COVERAGE(TARGET ${testName}_coverage OUTPUT ${testFile}-path NAME ${testFile} EXECUTABLE ${testName})
+                            ENDFOREACH( testFile )
             	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)
             #
             # Set the files that must be formatted by clang-format.
             #
             LIST (APPEND FORMATTING_INPUT_FILES ${MODULE_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
             #
             # Set the directories that doxygen must browse to generate the
             # documentation.
             #
             # Source directories:
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/docs")
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_INPUT_DIRS)
             # Source directories to exclude from the documentation generation
             #LIST (APPEND DOXYGEN_EXCLUDE_PATTERNS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir/*")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_EXCLUDE_PATTERNS)
             #
             # Set the directories with the sources to analyze and propagate the
             # modification to the parent scope
             #
             # Source directories to analyze:
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_INPUT_DIRS)
             # Source directories to exclude from the analysis
             #LIST (APPEND ANALYSIS_EXCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_EXCLUDE_DIRS)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages