libakerror/CMakeLists.txt

cmake_minimum_required(VERSION 3.10)
project(akerror LANGUAGES C)

include(GNUInstallDirs)
include(CMakePackageConfigHelpers)
include(CTest)

set(AKERR_USE_STDLIB 1 CACHE BOOL "Use the C standard library")
set(AKERR_COVERAGE 0 CACHE BOOL "Instrument the build with gcov coverage counters")
set(akerror_install_cmakedir "${CMAKE_INSTALL_LIBDIR}/cmake/akerror")

# Coverage instrumentation. Applied per target (not globally) so it never leaks
# into the exported/installed target interface. Only the library is
# instrumented: the tests are the thing doing the covering, and the public
# header's macros cannot be measured this way at all -- GCC attributes an
# expanded macro to its call site, so header logic shows up as test-file lines.
# Coverage of those macros is what mutation testing (--target
# include/akerror.tmpl.h) is for.
if(AKERR_COVERAGE)
    if(NOT CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
        message(FATAL_ERROR
            "AKERR_COVERAGE requires GCC or Clang, not ${CMAKE_C_COMPILER_ID}")
    endif()
    # -O0 keeps line counts attributable; no inlining or code motion.
    set(AKERR_COVERAGE_FLAGS --coverage -O0 -g)
    if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
        # Record absolute source paths so gcov resolves sources built from the
        # generated directory (GCC 8+; harmless to check).
        include(CheckCCompilerFlag)
        check_c_compiler_flag(-fprofile-abs-path AKERR_HAVE_PROFILE_ABS_PATH)
        if(AKERR_HAVE_PROFILE_ABS_PATH)
            list(APPEND AKERR_COVERAGE_FLAGS -fprofile-abs-path)
        endif()
    endif()
endif()

# Add coverage compile/link flags to one target, if coverage is enabled.
function(akerr_instrument_for_coverage _target)
    if(AKERR_COVERAGE)
        target_compile_options(${_target} PRIVATE ${AKERR_COVERAGE_FLAGS})
        set_property(TARGET ${_target} APPEND_STRING
                     PROPERTY LINK_FLAGS " --coverage")
    endif()
endfunction()

set(SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/scripts/generrno.sh)
set(INFILE ${CMAKE_CURRENT_SOURCE_DIR}/include/akerror.tmpl.h)

set(GENERATED_DIR ${CMAKE_CURRENT_BINARY_DIR}/generated)

set(GENERATED_ERRNO_C ${GENERATED_DIR}/src/errno.c)
set(GENERATED_AKERROR_H ${GENERATED_DIR}/include/akerror.h)

add_custom_command(
  OUTPUT ${GENERATED_ERRNO_C} ${GENERATED_AKERROR_H}
  COMMAND ${CMAKE_COMMAND} -E make_directory ${GENERATED_DIR}
  COMMAND /usr/bin/env bash
          ${SCRIPT}
          ${CMAKE_CURRENT_SOURCE_DIR}
          ${GENERATED_DIR}
  DEPENDS ${SCRIPT} ${INFILE}
  VERBATIM
)

add_library(akerror SHARED
  src/error.c
  ${GENERATED_ERRNO_C}
)

target_include_directories(akerror PUBLIC
  $<BUILD_INTERFACE:${GENERATED_DIR}/include>
  $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
)

find_package(PkgConfig REQUIRED)
add_library(akerror::akerror ALIAS akerror)

target_compile_definitions(akerror
    PUBLIC AKERR_USE_STDLIB=${AKERR_USE_STDLIB}
)

akerr_instrument_for_coverage(akerror)

# Each test is one source file in tests/ built into test_<name> and registered
# as CTest <name>. Tests expected to abort (unhandled error / contract
# violation) go in AKERR_WILL_FAIL_TESTS; all others must exit 0.
set(AKERR_TESTS
    err_catch
    err_cleanup
    err_trace
    err_improper_closure
    err_success
    err_pool_refcount
    err_handle_default
    err_handle_group
    err_handle_dispatch
    err_pass
    err_ignore
    err_swallow
    err_errno
    err_break_variants
    err_custom_handler
    err_error_names
    err_release_clears
    err_pool_exhaust
    err_maxval
    err_refcount_double_fail
    err_stacktrace_bounds
    err_name_bounds
    err_format_string
    err_unhandled_null
    err_release_null
    err_release_refcount
)

set(AKERR_WILL_FAIL_TESTS
    err_trace
    err_improper_closure
)

foreach(_test IN LISTS AKERR_TESTS)
    add_executable(test_${_test} tests/${_test}.c)
    target_include_directories(test_${_test} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/tests)
    target_link_libraries(test_${_test} PRIVATE akerror)
    add_test(NAME ${_test} COMMAND test_${_test})
endforeach()

set_tests_properties(
    ${AKERR_WILL_FAIL_TESTS}
    PROPERTIES WILL_FAIL TRUE
)

# Coverage and mutation testing are meta-checks on the test suite itself, and
# both rebuild and re-run the whole suite, so they are manual targets rather
# than CTest tests.
find_package(Python3 COMPONENTS Interpreter)
if(Python3_FOUND)
    # Code coverage: which library lines/branches the CTest suite reaches.
    #   cmake --build build --target coverage
    # The script configures and drives its own instrumented build tree (under
    # ${CMAKE_BINARY_DIR}/coverage) so this build's binaries and its coverage
    # counters can never be stale or half-instrumented. Reports via gcov.
    add_custom_target(coverage
        COMMAND ${Python3_EXECUTABLE}
                ${CMAKE_CURRENT_SOURCE_DIR}/scripts/coverage.py
                --source-root ${CMAKE_CURRENT_SOURCE_DIR}
                --build-dir ${CMAKE_CURRENT_BINARY_DIR}/coverage
                --cmake ${CMAKE_COMMAND}
                --ctest ${CMAKE_CTEST_COMMAND}
        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
        USES_TERMINAL
        COMMENT "Running the test suite instrumented for coverage"
    )

    # Mutation testing: break the library in small ways and confirm the test
    # suite notices.
    #   cmake --build build --target mutation
    # When embedded in another project, use a namespaced target to avoid
    # collisions with mutation targets provided by sibling dependencies.
    if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
        set(AKERR_MUTATION_TARGET mutation)
    else()
        set(AKERR_MUTATION_TARGET akerror_mutation)
    endif()
    add_custom_target(${AKERR_MUTATION_TARGET}
        COMMAND ${Python3_EXECUTABLE}
                ${CMAKE_CURRENT_SOURCE_DIR}/scripts/mutation_test.py
                --source-root ${CMAKE_CURRENT_SOURCE_DIR}
        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
        USES_TERMINAL
        COMMENT "Running mutation tests (breaks the library, expects tests to fail)"
    )
endif()

set(main_lib_dest "lib/my_library-${MY_LIBRARY_VERSION}")
install(TARGETS akerror
  EXPORT akerrorTargets
  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
  INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)

install(FILES ${GENERATED_AKERROR_H} DESTINATION "include/")
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/akerror.pc DESTINATION "lib/pkgconfig/")

install(EXPORT akerrorTargets
    FILE akerrorTargets.cmake
    NAMESPACE akerror::
    DESTINATION ${akerror_install_cmakedir}
)

configure_package_config_file(
    cmake/akerror.cmake.in
    "${CMAKE_CURRENT_BINARY_DIR}/akerrorConfig.cmake"
    INSTALL_DESTINATION ${akerror_install_cmakedir}
)

install(FILES
    "${CMAKE_CURRENT_BINARY_DIR}/akerrorConfig.cmake"
    DESTINATION ${akerror_install_cmakedir}
)

# pkgconfig
set(prefix      ${CMAKE_INSTALL_PREFIX})
set(exec_prefix "\${prefix}")
set(libdir      "\${exec_prefix}/lib")
set(includedir  "\${prefix}/include")
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/akerror.pc.in ${CMAKE_CURRENT_BINARY_DIR}/akerror.pc @ONLY)