GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r42:268b32cf0b31

Ajout de la couverture de code avec gcov, lcov & genpath

perrinel -

r42:268b32cf0b31

parent child

Context file:

r42:268b32cf0b31

cmake/sciqlop_applications.cmake +4 0

             #
             # 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)
             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_code_coverage.cmake +10 -68

             # 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(oneValueArgs NAME TARGET OUTPUT)
                 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...")
+                    message(FATAL_ERROR "lcov not found! Aborting...")
                 endif() # NOT LCOV_PATH
                 if(NOT GENHTML_PATH)
-            #        message(FATAL_ERROR "genhtml not found! Aborting...")
+                    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
+                    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
+                    # Capturing lcov counters and generating report
-            #        COMMAND ${LCOV_PATH} --remove ${Coverage_NAME}.info ${COVERAGE_EXCLUDES} --output-file ${Coverage_NAME}.info.cleaned
+                    COMMAND ${LCOV_PATH} --directory . --capture --output-file ${Coverage_NAME}.info
-            #        COMMAND ${GENHTML_PATH} -o ${Coverage_NAME} ${Coverage_NAME}.info.cleaned
+                    COMMAND ${LCOV_PATH} --remove ${Coverage_NAME}.info ${COVERAGE_EXCLUDES} --output-file ${Coverage_NAME}.info.cleaned
-            #        COMMAND ${CMAKE_COMMAND} -E remove ${Coverage_NAME}.info ${Coverage_NAME}.info.cleaned
+                    COMMAND ${GENHTML_PATH} -o  ${Coverage_OUTPUT} ${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
+            endfunction()
-            # 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

core/CMakeLists.txt +1 -6

             ## 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)
                             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_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})
                             set(Coverage_NAME ${testName})
-                            SETUP_TARGET_FOR_COVERAGE(TARGET ${testName}_coverage NAME ${testFile} EXECUTABLE ${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