From aa0b06d3b944737ebdb88aef94ff805f2bff5214 Mon Sep 17 00:00:00 2001 From: kakwa Date: Sat, 6 Jan 2018 00:19:03 +0100 Subject: [PATCH] trying to add coverage test --- .gitignore | 3 + .travis.yml | 29 ++++- CMakeLists.txt | 47 +++++--- cmake/CodeCoverage.cmake | 238 +++++++++++++++++++++++++++++++++++++++ tests/test.c | 65 +++++++++++ 5 files changed, 361 insertions(+), 21 deletions(-) create mode 100644 cmake/CodeCoverage.cmake create mode 100644 tests/test.c diff --git a/.gitignore b/.gitignore index 621b9dfe..69747c1b 100644 --- a/.gitignore +++ b/.gitignore @@ -40,5 +40,8 @@ out # external build directory external-build +coverage +emf2svg-test + # exceptions !tests/resources/filesmasher-master/Makefile diff --git a/.travis.yml b/.travis.yml index 2824d537..e599502b 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,9 +1,23 @@ matrix: include: + - os: osx + compiler: clang + env: + N=OSX + LAST_CMD="./tests/resources/check_correctness.sh -r -s -n && ./tests/resources/check_correctness.sh -r -s -e tests/resources/emf-corrupted/ -xNn" - os: linux dist: trusty - - os: osx - env: OPTS=-n + compiler: clang + env: + N=BASE + LAST_CMD="./tests/resources/check_correctness.sh -r -s && ./tests/resources/check_correctness.sh -r -s -e tests/resources/emf-corrupted/ -xN" + - os: linux + dist: trusty + env: + N=GCOV + CMAKE_ARG="-DGCOV=ON" + LAST_CMD="make coverage" + sudo: required @@ -13,6 +27,7 @@ before_install: - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install argp-standalone; fi - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install valgrind; fi - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install libxml2; fi + - if [[ "$N" == "GCOV" ]]; then pip install --user cpp-coveralls; fi addons: apt: @@ -24,9 +39,15 @@ addons: - libc6-dev - gcc - g++ + - gcc + - g++ + - lcov + language: cpp -compiler: clang -script: cmake . -DFORCELE=ON && make && ./tests/resources/check_correctness.sh -r -s $OPTS && ./tests/resources/check_correctness.sh -r -s -e tests/resources/emf-corrupted/ -xN $OPTS +script: cmake . -DFORCELE=ON $CMAKE_ARG && make && $LAST_CMD + +after_success: + - if [[ "$N" == "GCOV" ]];then ~/.local/bin/coveralls -E '.*conv.*' -E '.*uemf.*' -E '.*upmf.*' -E '.*tests.*' --gcov-options '\-lp';fi diff --git a/CMakeLists.txt b/CMakeLists.txt index e8086d6d..d7e84641 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -22,36 +22,30 @@ add_custom_target(tag # set version as a definition -set(CMAKE_C_FLAGS "${CMAKE_CXX_FLAGS} -DE2S_VERSION='\"${emf2svg_VERSION}\"'") +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DE2S_VERSION='\"${emf2svg_VERSION}\"'") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DE2S_VERSION='\"${emf2svg_VERSION}\"'") # Options -option(DEBUG "compile with debug symbol" OFF) +option(GCOV "compile with gcov support" OFF) +option(UNITTEST "compile unit tests" OFF) option(INDEX "print record indexes" OFF) option(STATIC "compile statically" OFF) -option(USE_CLANG "build application with clang" OFF) -option(USE_GCC "build application with gcc" OFF) option(FORCELE "force little endian architecture" OFF) +if(GCOV) + SET(UNITTEST ON) + SET(CMAKE_BUILD_TYPE "Debug") +endif(GCOV) + if(INDEX) set(CMAKE_C_FLAGS "${CMAKE_CXX_FLAGS} -DRECORD_INDEX='true'") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DRECORD_INDEX='true'") endif(INDEX) -if(USE_CLANG) - set(CMAKE_CXX_COMPILER "clang++") - set(CMAKE_CC_COMPILER "clang" ) -endif(USE_CLANG) - -if(USE_GCC) - set(CMAKE_CXX_COMPILER "g++") - set(CMAKE_CC_COMPILER "gcc") -endif(USE_GCC) - -if(DEBUG) +if(CMAKE_BUILD_TYPE STREQUAL "Debug") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0 -g") set(CMAKE_BUILD_TYPE Debug) -endif(DEBUG) +endif() if(STATIC) set(SHARED "") @@ -141,11 +135,30 @@ target_link_libraries(emf2svg ${FONTCONFIG_LIBRARIES} ) - target_link_libraries(emf2svg-conv emf2svg ) +if(GCOV) + Set(COVERAGE_EXCLUDES '*conv*' '*uemf*' '*upmf*' '*tests*' '*c++*') + include(CodeCoverage) + setup_target_for_coverage(NAME coverage + EXECUTABLE emf2svg-test ./tests/resources/emf*/* + DEPENDENCIES emf2svg-test + ) + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage") + SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage") +endif(GCOV) + +if(UNITTEST) + add_executable(emf2svg-test tests/test.c) + + target_link_libraries(emf2svg-test + emf2svg + ) +endif(UNITTEST) + + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11 -Wall") diff --git a/cmake/CodeCoverage.cmake b/cmake/CodeCoverage.cmake new file mode 100644 index 00000000..2527b3c2 --- /dev/null +++ b/cmake/CodeCoverage.cmake @@ -0,0 +1,238 @@ +# 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 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 .. +# 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" + +if(CMAKE_C_COMPILER_ID STREQUAL "GNU") + 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) + 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 + + # Setup target + add_custom_target(${Coverage_NAME} + + # Cleanup lcov + COMMAND ${LCOV_PATH} --directory . --zerocounters + # Create baseline to make sure untouched files show up in the report + COMMAND ${LCOV_PATH} -c -i -d . -o ${Coverage_NAME}.base + + # Run tests + COMMAND ${Coverage_EXECUTABLE} + + # Capturing lcov counters and generating report + COMMAND ${LCOV_PATH} --directory . --capture --output-file ${Coverage_NAME}.info + # add baseline counters + COMMAND ${LCOV_PATH} -a ${Coverage_NAME}.base -a ${Coverage_NAME}.info --output-file ${Coverage_NAME}.total + COMMAND ${LCOV_PATH} --remove ${Coverage_NAME}.total ${COVERAGE_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}.info ${Coverage_NAME}.total ${PROJECT_BINARY_DIR}/${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 + 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 + +# 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_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 diff --git a/tests/test.c b/tests/test.c new file mode 100644 index 00000000..14046790 --- /dev/null +++ b/tests/test.c @@ -0,0 +1,65 @@ +#include +#include +#include +#include +#include +#include +#include + +/* to compile: gcc -Wall -std=c99 -lm -lemf2svg ./example.c -o test */ +int main(int argc, char *argv[]){ + + // quick and dirty way to load the file in memory + if (argc < 2){fprintf(stderr, "not enough args\n"); exit(1);} + int ret = 0; + + for(int i = 0; i < argc; i++){ + struct stat s; const char * file_name = argv[i]; + fprintf(stderr, "opening file '%s'\n", argv[i]); + int fd = open(file_name, O_RDONLY); + if (fd < 0){fprintf(stderr, "file access failed\n"); exit(1);} + fstat (fd, &s); + + /* return code for check and conversion */ + + /* emf content size */ + size_t emf_size = s.st_size; + /* emf content */ + char * emf_content = mmap(0, emf_size, PROT_READ, MAP_PRIVATE, fd, 0); + + /***********************************************************************/ + + /* svg output string */ + char *svg_out = NULL; + /* svg output length */ + size_t svg_out_len; + + /*************************** options settings **************************/ + + /* allocate the options structure) */ + generatorOptions *options = (generatorOptions *)calloc(1, \ + sizeof(generatorOptions)); + options->verbose = true; + options->emfplus = true; + options->nameSpace = (char *)"svg"; + options->svgDelimiter = true; + options->imgWidth = 0; + options->imgHeight = 0; + + /***************************** conversion ******************************/ + + fclose(stdout); + ret =+ emf2svg(emf_content, emf_size, &svg_out, &svg_out_len, options); + fopen("/dev/console", "w"); + + /***********************************************************************/ + + // free the allocated structures + free(svg_out); + free(options); + close(fd); + munmap(emf_content, emf_size); + } + // return + exit(!ret); +}