1
=== modified file 'CMakeLists.txt'
2
--- CMakeLists.txt	2014-04-30 16:00:10 +0000
3
+++ CMakeLists.txt	2014-05-02 22:12:55 +0000
4
@@ -10,6 +10,8 @@
5
10
SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2 -g -Wall -Wextra -Werror -fPIC")
10
SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2 -g -Wall -Wextra -Werror -fPIC")
6
11
SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -O2 -g -Wextra -Wall -Werror -fPIC")
11
SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -O2 -g -Wextra -Wall -Werror -fPIC")
7
12
12
8
13
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
9
14
10
13
include(GNUInstallDirs)
15
include(GNUInstallDirs)
11
14
16
12
15
set(SCOPE_LIB_DIR ${CMAKE_INSTALL_FULL_LIBDIR}/unity-scopes/clickscope/)
17
set(SCOPE_LIB_DIR ${CMAKE_INSTALL_FULL_LIBDIR}/unity-scopes/clickscope/)
13
@@ -38,6 +40,24 @@
14
38
add_subdirectory(data)
40
add_subdirectory(data)
15
39
add_subdirectory(po)
41
add_subdirectory(po)
16
40
42
17
43
include(EnableCoverageReport) # Using gcov CMake modules from http://code.cor-lab/projects/rsc
18
44
#####################################################################
19
45
# Enable code coverage calculation with gcov/gcovr/lcov
20
46
# Usage:
21
47
#  * Switch build type to coverage (use ccmake or cmake-gui)
22
48
#  * Invoke make, make test, make coverage (or ninja if you use that backend)
23
49
#  * Find html report in subdir coveragereport
24
50
#  * Find xml report feasible for jenkins in coverage.xml
25
51
#####################################################################
26
52
string(TOLOWER "${CMAKE_BUILD_TYPE}" cmake_build_type_lower)
27
53
if(cmake_build_type_lower MATCHES coverage)
28
54
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage" )
29
55
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage" )
30
56
  set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} --coverage" )
31
57
  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} --coverage" )
32
58
  ENABLE_COVERAGE_REPORT(TARGETS ${SCOPE_LIB_UNVERSIONED} FILTER /usr/include ${CMAKE_SOURCE_DIR}/tests/* ${CMAKE_BINARY_DIR}/*)
33
59
endif()
34
60
35
41
# Custom targets for the tests
61
# Custom targets for the tests
36
42
add_custom_target (test
62
add_custom_target (test
37
43
  DEPENDS test-click-scope
63
  DEPENDS test-click-scope
38
44
64
39
=== added directory 'cmake'
40
=== added file 'cmake/EnableCoverageReport.cmake'
41
--- cmake/EnableCoverageReport.cmake	1970-01-01 00:00:00 +0000
42
+++ cmake/EnableCoverageReport.cmake	2014-05-02 22:12:55 +0000
43
@@ -0,0 +1,158 @@
44
1
# - Creates a special coverage build type and target on GCC.
45
2
#
46
3
# Defines a function ENABLE_COVERAGE_REPORT which generates the coverage target
47
4
# for selected targets. Optional arguments to this function are used to filter
48
5
# unwanted results using globbing expressions. Moreover targets with tests for
49
6
# the source code can be specified to trigger regenerating the report if the
50
7
# test has changed
51
8
#
52
9
# ENABLE_COVERAGE_REPORT(TARGETS target... [FILTER filter...] [TESTS test targets...])
53
10
#
54
11
# To generate a coverage report first build the project with
55
12
# CMAKE_BUILD_TYPE=coverage, then call make test and afterwards make coverage.
56
13
#
57
14
# The coverage report is based on gcov. Depending on the availability of lcov
58
15
# a HTML report will be generated and/or an XML report of gcovr is found.
59
16
# The generated coverage target executes all found solutions. Special targets
60
17
# exist to create e.g. only the xml report: coverage-xml. 
61
18
#
62
19
# Copyright (C) 2010 by Johannes Wienke <jwienke at techfak dot uni-bielefeld dot de>
63
20
#
64
21
# This file may be licensed under the terms of the
65
22
# GNU Lesser General Public License Version 3 (the ``LGPL''),
66
23
# or (at your option) any later version.
67
24
#
68
25
# Software distributed under the License is distributed
69
26
# on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
70
27
# express or implied. See the LGPL for the specific language
71
28
# governing rights and limitations.
72
29
#
73
30
# You should have received a copy of the LGPL along with this
74
31
# program. If not, go to http://www.gnu.org/licenses/lgpl.html
75
32
# or write to the Free Software Foundation, Inc.,
76
33
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
77
34
#
78
35
# The development of this software was supported by:
79
36
#   CoR-Lab, Research Institute for Cognition and Robotics
80
37
#     Bielefeld University
81
38
82
39
FIND_PACKAGE(Lcov)
83
40
FIND_PACKAGE(gcovr)
84
41
85
42
FUNCTION(ENABLE_COVERAGE_REPORT)
86
43
    
87
44
    # argument parsing
88
45
    SET(MULTI_VALUE_ARGS FILTER TARGETS TESTS)
89
46
    CMAKE_PARSE_ARGUMENTS(ENABLE_COVERAGE_REPORT "" "" "${MULTI_VALUE_ARGS}" ${ARGN})
90
47
91
48
    SET(COVERAGE_RAW_FILE "${CMAKE_BINARY_DIR}/coverage.raw.info")
92
49
    SET(COVERAGE_FILTERED_FILE "${CMAKE_BINARY_DIR}/coverage.info")
93
50
    SET(COVERAGE_REPORT_DIR "${CMAKE_BINARY_DIR}/coveragereport")
94
51
    SET(COVERAGE_XML_FILE "${CMAKE_BINARY_DIR}/coverage.xml")
95
52
    SET(COVERAGE_XML_COMMAND_FILE "${CMAKE_BINARY_DIR}/coverage-xml.cmake")
96
53
    
97
54
    # decide if there is any tool to create coverage data
98
55
    SET(TOOL_FOUND FALSE)
99
56
    IF(LCOV_FOUND OR GCOVR_FOUND)
100
57
        SET(TOOL_FOUND TRUE)
101
58
    ENDIF()
102
59
    IF(NOT TOOL_FOUND)
103
60
        MESSAGE(STATUS "Cannot enable coverage targets because neither lcov nor gcovr are found.")
104
61
    ENDIF()
105
62
    
106
63
    STRING(TOLOWER "${CMAKE_BUILD_TYPE}" COVERAGE_BUILD_TYPE)
107
64
    IF(CMAKE_COMPILER_IS_GNUCXX AND TOOL_FOUND AND "${COVERAGE_BUILD_TYPE}" MATCHES "coverage")
108
65
    
109
66
        MESSAGE(STATUS "Coverage support enabled for targets: ${ENABLE_COVERAGE_REPORT_TARGETS}")
110
67
    
111
68
        # create coverage build type
112
69
        SET(CMAKE_CXX_FLAGS_COVERAGE ${CMAKE_CXX_FLAGS_DEBUG} PARENT_SCOPE)
113
70
        SET(CMAKE_C_FLAGS_COVERAGE ${CMAKE_C_FLAGS_DEBUG} PARENT_SCOPE)
114
71
        SET(CMAKE_CONFIGURATION_TYPES ${CMAKE_CONFIGURATION_TYPES} coverage PARENT_SCOPE)
115
72
    
116
73
        # instrument targets
117
74
        SET_TARGET_PROPERTIES(${ENABLE_COVERAGE_REPORT_TARGETS} PROPERTIES COMPILE_FLAGS --coverage
118
75
                                                        LINK_FLAGS --coverage)
119
76
    
120
77
        # html report
121
78
        IF (LCOV_FOUND)
122
79
        
123
80
            MESSAGE(STATUS "Enabling HTML coverage report")
124
81
    
125
82
            # set up coverage target
126
83
            
127
84
            ADD_CUSTOM_COMMAND(OUTPUT ${COVERAGE_RAW_FILE}
128
85
                               COMMAND ${LCOV_EXECUTABLE} -c -d ${CMAKE_BINARY_DIR} -o ${COVERAGE_RAW_FILE}
129
86
                               WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
130
87
                               COMMENT "Collecting coverage data"
131
88
                               DEPENDS ${ENABLE_COVERAGE_REPORT_TARGETS} ${ENABLE_COVERAGE_REPORT_TESTS}
132
89
                               VERBATIM)
133
90
            
134
91
            # filter unwanted stuff
135
92
            LIST(LENGTH ENABLE_COVERAGE_REPORT_FILTER FILTER_LENGTH)
136
93
            IF(${FILTER_LENGTH} GREATER 0)
137
94
                SET(FILTER COMMAND ${LCOV_EXECUTABLE})
138
95
                FOREACH(F ${ENABLE_COVERAGE_REPORT_FILTER})
139
96
                    SET(FILTER ${FILTER} -r ${COVERAGE_FILTERED_FILE} ${F})
140
97
                ENDFOREACH()
141
98
                SET(FILTER ${FILTER} -o ${COVERAGE_FILTERED_FILE})
142
99
            ELSE()
143
100
                SET(FILTER "")
144
101
            ENDIF()
145
102
            
146
103
            ADD_CUSTOM_COMMAND(OUTPUT ${COVERAGE_FILTERED_FILE}
147
104
                               COMMAND ${LCOV_EXECUTABLE} -e ${COVERAGE_RAW_FILE} "${CMAKE_SOURCE_DIR}*"  -o ${COVERAGE_FILTERED_FILE}
148
105
                               ${FILTER}
149
106
                               DEPENDS ${COVERAGE_RAW_FILE}
150
107
                               COMMENT "Filtering recorded coverage data for project-relevant entries"
151
108
                               VERBATIM)
152
109
            ADD_CUSTOM_COMMAND(OUTPUT ${COVERAGE_REPORT_DIR}
153
110
                               COMMAND ${CMAKE_COMMAND} -E make_directory ${COVERAGE_REPORT_DIR}
154
111
                               COMMAND ${GENHTML_EXECUTABLE} --legend --show-details -t "${PROJECT_NAME} test coverage" -o ${COVERAGE_REPORT_DIR} ${COVERAGE_FILTERED_FILE}
155
112
                               DEPENDS ${COVERAGE_FILTERED_FILE}
156
113
                               COMMENT "Generating HTML coverage report in ${COVERAGE_REPORT_DIR}"
157
114
                               VERBATIM)
158
115
                               
159
116
            ADD_CUSTOM_TARGET(coverage-html
160
117
                              DEPENDS ${COVERAGE_REPORT_DIR})
161
118
                              
162
119
        ENDIF()
163
120
        
164
121
        # xml coverage report
165
122
        IF(GCOVR_FOUND)
166
123
        
167
124
            MESSAGE(STATUS "Enabling XML coverage report")
168
125
        
169
126
            # gcovr cannot write directly to a file so the execution needs to
170
127
            # be wrapped in a cmake file that generates the file output
171
128
            FILE(WRITE ${COVERAGE_XML_COMMAND_FILE}
172
129
                 "SET(ENV{LANG} en)\n")
173
130
            FILE(APPEND ${COVERAGE_XML_COMMAND_FILE}
174
131
                 "EXECUTE_PROCESS(COMMAND \"${GCOVR_EXECUTABLE}\" -x -r \"${CMAKE_SOURCE_DIR}\" OUTPUT_FILE \"${COVERAGE_XML_FILE}\" WORKING_DIRECTORY \"${CMAKE_BINARY_DIR}\")\n")
175
132
        
176
133
            ADD_CUSTOM_COMMAND(OUTPUT ${COVERAGE_XML_FILE}
177
134
                               COMMAND ${CMAKE_COMMAND} ARGS -P ${COVERAGE_XML_COMMAND_FILE}
178
135
                               COMMENT "Generating coverage XML report"
179
136
                               VERBATIM)
180
137
                               
181
138
            ADD_CUSTOM_TARGET(coverage-xml
182
139
                              DEPENDS ${COVERAGE_XML_FILE})
183
140
        
184
141
        ENDIF()
185
142
        
186
143
        # provide a global coverage target executing both steps if available
187
144
        SET(GLOBAL_DEPENDS "")
188
145
        IF(LCOV_FOUND)
189
146
            LIST(APPEND GLOBAL_DEPENDS ${COVERAGE_REPORT_DIR})
190
147
        ENDIF()
191
148
        IF(GCOVR_FOUND)
192
149
            LIST(APPEND GLOBAL_DEPENDS ${COVERAGE_XML_FILE})
193
150
        ENDIF()
194
151
        IF(LCOV_FOUND OR GCOVR_FOUND)
195
152
            ADD_CUSTOM_TARGET(coverage
196
153
                              DEPENDS ${GLOBAL_DEPENDS})
197
154
        ENDIF()
198
155
                          
199
156
    ENDIF()
200
157
201
158
ENDFUNCTION()   
202
0
159
203
=== added file 'cmake/FindLcov.cmake'
204
--- cmake/FindLcov.cmake	1970-01-01 00:00:00 +0000
205
+++ cmake/FindLcov.cmake	2014-05-02 22:12:55 +0000
206
@@ -0,0 +1,35 @@
207
1
# - Find lcov 
208
2
# Will define:
209
3
#
210
4
# LCOV_EXECUTABLE - the lcov binary
211
5
# GENHTML_EXECUTABLE - the genhtml executable
212
6
#
213
7
# Copyright (C) 2010 by Johannes Wienke <jwienke at techfak dot uni-bielefeld dot de>
214
8
#
215
9
# This file may be licensed under the terms of the
216
10
# GNU Lesser General Public License Version 3 (the ``LGPL''),
217
11
# or (at your option) any later version.
218
12
#
219
13
# Software distributed under the License is distributed
220
14
# on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
221
15
# express or implied. See the LGPL for the specific language
222
16
# governing rights and limitations.
223
17
#
224
18
# You should have received a copy of the LGPL along with this
225
19
# program. If not, go to http://www.gnu.org/licenses/lgpl.html
226
20
# or write to the Free Software Foundation, Inc.,
227
21
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
228
22
#
229
23
# The development of this software was supported by:
230
24
#   CoR-Lab, Research Institute for Cognition and Robotics
231
25
#     Bielefeld University
232
26
233
27
INCLUDE(FindPackageHandleStandardArgs)
234
28
235
29
FIND_PROGRAM(LCOV_EXECUTABLE lcov)
236
30
FIND_PROGRAM(GENHTML_EXECUTABLE genhtml)
237
31
238
32
FIND_PACKAGE_HANDLE_STANDARD_ARGS(Lcov DEFAULT_MSG LCOV_EXECUTABLE GENHTML_EXECUTABLE)
239
33
240
34
# only visible in advanced view
241
35
MARK_AS_ADVANCED(LCOV_EXECUTABLE GENHTML_EXECUTABLE)
242
0
36
243
=== added file 'cmake/Findgcovr.cmake'
244
--- cmake/Findgcovr.cmake	1970-01-01 00:00:00 +0000
245
+++ cmake/Findgcovr.cmake	2014-05-02 22:12:55 +0000
246
@@ -0,0 +1,43 @@
247
1
# - Find gcovr scrip 
248
2
# Will define:
249
3
#
250
4
# GCOVR_EXECUTABLE - the gcovr script
251
5
#
252
6
# Uses:
253
7
#
254
8
# GCOVR_ROOT - root to search for the script
255
9
#
256
10
# Copyright (C) 2011 by Johannes Wienke <jwienke at techfak dot uni-bielefeld dot de>
257
11
#
258
12
# This file may be licensed under the terms of the
259
13
# GNU Lesser General Public License Version 3 (the ``LGPL''),
260
14
# or (at your option) any later version.
261
15
#
262
16
# Software distributed under the License is distributed
263
17
# on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
264
18
# express or implied. See the LGPL for the specific language
265
19
# governing rights and limitations.
266
20
#
267
21
# You should have received a copy of the LGPL along with this
268
22
# program. If not, go to http://www.gnu.org/licenses/lgpl.html
269
23
# or write to the Free Software Foundation, Inc.,
270
24
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
271
25
#
272
26
# The development of this software was supported by:
273
27
#   CoR-Lab, Research Institute for Cognition and Robotics
274
28
#     Bielefeld University
275
29
276
30
INCLUDE(FindPackageHandleStandardArgs)
277
31
278
32
FIND_PROGRAM(GCOVR_EXECUTABLE gcovr
279
33
             HINTS ${GCOVR_ROOT}
280
34
                   "${GCOVR_ROOT}/bin"
281
35
                   "${GCOVR_ROOT}/share/python"
282
36
                   "/usr/share/python"
283
37
                   "/usr/local/share/python"
284
38
                   "${CMAKE_INSTALL_PREFIX}/share/python")
285
39
286
40
FIND_PACKAGE_HANDLE_STANDARD_ARGS(gcovr DEFAULT_MSG GCOVR_EXECUTABLE)
287
41
288
42
# only visible in advanced view
289
43
MARK_AS_ADVANCED(GCOVR_EXECUTABLE)
290
0
44
291
=== modified file 'debian/copyright'
292
--- debian/copyright	2014-03-24 19:18:13 +0000
293
+++ debian/copyright	2014-05-02 22:12:55 +0000
294
@@ -18,3 +18,18 @@
295
18
 .
18
 .
296
19
 On Debian/Ubuntu systems, the full text of the GPL v3 can be found in
19
 On Debian/Ubuntu systems, the full text of the GPL v3 can be found in
297
20
 `/usr/share/common-licenses/GPL-3'
20
 `/usr/share/common-licenses/GPL-3'
298
21
299
22
Files: cmake/EnableCoverageReport.cmake cmake/Findgcovr.cmake cmake/FindLcov.cmake
300
23
Copyright: 2010 Johannes Wienke
301
24
License: LGPL-3
302
25
 This file may be licensed under the terms of the
303
26
 GNU Lesser General Public License Version 3 (the ``LGPL''),
304
27
 or (at your option) any later version.
305
28
 .
306
29
 Software distributed under the License is distributed
307
30
 on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
308
31
 express or implied. See the LGPL for the specific language
309
32
 governing rights and limitations.
310
33
 .
311
34
 On Debian/Ubuntu systems, the full text of the LGPL v3 can be found in
312
35
 `/usr/share/common-licenses/LGPL-3'
Reviewer	Review Type	Date Requested	Status
PS Jenkins bot	continuous-integration	2014-05-02	Needs Fixing on 2014-05-02
dobey		2014-05-02	Pending
Review via email: mp+218164@code.launchpad.net