test.cmake

cmake_minimum_required(VERSION 3.18...4.1 FATAL_ERROR)

set(ENV{LANG} "C")
set(ENV{LC_ALL} "C")
set(CTEST_USE_LAUNCHERS TRUE)

if(EXISTS "/etc/os-release")
  file(STRINGS "/etc/os-release" OS_NAME REGEX "^ID=.*$")
  string(REGEX REPLACE "ID=[\"']?([^\"']*)[\"']?$" "\\1" OS_NAME "${OS_NAME}")
  file(STRINGS "/etc/os-release" OS_VERSION REGEX "^VERSION_ID=.*$")
  string(REGEX REPLACE "VERSION_ID=[\"']?([^\"'.]*).*$" "\\1" OS_VERSION "${OS_VERSION}")
  file(STRINGS "/etc/os-release" OS_FULL_NAME REGEX "^PRETTY_NAME=.*$")
  string(REGEX REPLACE "PRETTY_NAME=[\"']?([^\"']*)[\"']?$" "\\1" OS_FULL_NAME "${OS_FULL_NAME}")
  string(REGEX REPLACE "[ ]*\\(.*\\)" "" OS_FULL_NAME "${OS_FULL_NAME}")
elseif(APPLE)
  set(OS_NAME "macOS")
  execute_process(COMMAND sw_vers -productVersion
    OUTPUT_VARIABLE OS_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE)
  set(OS_FULL_NAME "${OS_NAME} ${OS_VERSION}")
else()
  cmake_host_system_information(RESULT OS_NAME QUERY OS_NAME)
  cmake_host_system_information(RESULT OS_VERSION QUERY OS_VERSION)
  set(OS_FULL_NAME "${OS_NAME} ${OS_VERSION}")
endif()

cmake_host_system_information(RESULT
  NCORES QUERY NUMBER_OF_PHYSICAL_CORES)
cmake_host_system_information(RESULT
  NTHREADS QUERY NUMBER_OF_LOGICAL_CORES)

if(NOT DEFINED ENV{CMAKE_BUILD_PARALLEL_LEVEL})
  set(ENV{CMAKE_BUILD_PARALLEL_LEVEL} ${NTHREADS})
endif()

if(NOT DEFINED ENV{CTEST_PARALLEL_LEVEL})
  set(ENV{CTEST_PARALLEL_LEVEL} ${NCORES})
endif()

if(NOT DEFINED CTEST_CONFIGURATION_TYPE)
  if(DEFINED ENV{CMAKE_BUILD_TYPE})
    set(CTEST_CONFIGURATION_TYPE $ENV{CMAKE_BUILD_TYPE})
  else()
    set(CTEST_CONFIGURATION_TYPE Debug)
    set(CMAKE_C_FLAGS "-Og -fno-omit-frame-pointer")
    set(CMAKE_CXX_FLAGS "-Og -fno-omit-frame-pointer")
  endif()
endif()

execute_process(COMMAND ${CMAKE_COMMAND} --system-information
  OUTPUT_VARIABLE CMAKE_SYSTEM_INFORMATION ERROR_VARIABLE ERROR)

if(ERROR)
  message(FATAL_ERROR "Cannot detect system information")
endif()

string(REGEX REPLACE ".+CMAKE_CXX_COMPILER \"([^\"]+)\".*$" "\\1"
  COMPILER "${CMAKE_SYSTEM_INFORMATION}")

string(REGEX REPLACE ".+CMAKE_CXX_COMPILER_ID \"([-0-9A-Za-z ]+)\".*$" "\\1"
  COMPILER_ID "${CMAKE_SYSTEM_INFORMATION}")
string(REPLACE "GNU" "GCC" COMPILER_ID "${COMPILER_ID}")

string(REGEX REPLACE ".+CMAKE_CXX_COMPILER_VERSION \"([^\"]+)\".*$" "\\1"
  COMPILER_VERSION "${CMAKE_SYSTEM_INFORMATION}")

set(CTEST_BUILD_NAME "${OS_FULL_NAME}")
string(APPEND CTEST_BUILD_NAME " ${COMPILER_ID} ${COMPILER_VERSION}")
string(APPEND CTEST_BUILD_NAME " ${CTEST_CONFIGURATION_TYPE}")

if(DEFINED ENV{CMAKE_GENERATOR})
  set(CTEST_CMAKE_GENERATOR $ENV{CMAKE_GENERATOR})
else()
  string(REGEX REPLACE ".+CMAKE_GENERATOR \"([-0-9A-Za-z ]+)\".*$" "\\1"
    CTEST_CMAKE_GENERATOR "${CMAKE_SYSTEM_INFORMATION}")
endif()

if(NOT CTEST_CMAKE_GENERATOR MATCHES "Makefile")
  string(APPEND CTEST_BUILD_NAME " ${CTEST_CMAKE_GENERATOR}")
endif()

if(NOT CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
  string(APPEND CTEST_BUILD_NAME " ${CMAKE_SYSTEM_PROCESSOR}")
endif()

if(DEFINED ENV{CFLAGS})
  set(CMAKE_C_FLAGS $ENV{CFLAGS})
endif()

if(DEFINED ENV{CXXFLAGS})
  set(CMAKE_CXX_FLAGS $ENV{CXXFLAGS})
endif()

if(COVERAGE)
  string(APPEND CTEST_BUILD_NAME " [Coverage]")
  find_program(CTEST_COVERAGE_COMMAND NAMES gcov)
  if(NOT CTEST_COVERAGE_COMMAND)
    message(FATAL_ERROR "Could not find gcov command")
  endif()
  set(COVERAGE_FLAGS "--coverage -fprofile-update=atomic -DENABLE_COVERAGE")
  list(PREPEND CMAKE_C_FLAGS "${COVERAGE_FLAGS}")
  list(PREPEND CMAKE_CXX_FLAGS "${COVERAGE_FLAGS}")
endif()

if(MEMCHECK)
  set(CTEST_MEMORYCHECK_TYPE "Valgrind")
  string(APPEND CTEST_BUILD_NAME " [Valgrind]")
  find_program(CTEST_MEMORYCHECK_COMMAND NAMES valgrind)
  if(NOT CTEST_MEMORYCHECK_COMMAND)
    message(FATAL_ERROR "Could not find valgrind")
  endif()
endif()

if(NOT DEFINED CTEST_SOURCE_DIRECTORY)
  set(CTEST_SOURCE_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}")
endif()

if(NOT DEFINED CTEST_BINARY_DIRECTORY)
  get_filename_component(CTEST_BINARY_DIRECTORY "build" REALPATH)
endif()

if(SANITIZE)
  list(PREPEND CMAKE_C_FLAGS -fsanitize=${SANITIZE})
  list(PREPEND CMAKE_CXX_FLAGS -fsanitize=${SANITIZE})
  set(ENV{LD_LIBRARY_PATH} ${CTEST_BINARY_DIRECTORY}/lib)

  if(NOT CMAKE_CXX_FLAGS MATCHES "-fno-omit-frame-pointer")
    list(APPEND CMAKE_C_FLAGS -fno-omit-frame-pointer)
    list(APPEND CMAKE_CXX_FLAGS -fno-omit-frame-pointer)
  endif()

  list(APPEND CMAKE_C_FLAGS -fno-optimize-sibling-calls)
  list(APPEND CMAKE_CXX_FLAGS -fno-optimize-sibling-calls)

  if(SANITIZE STREQUAL "address")
    set(CTEST_MEMORYCHECK_TYPE "AddressSanitizer")
    set(OPTIONS detect_leaks=0 detect_odr_violation=1 verify_asan_link_order=0)
    set(RUNTIME asan)
  elseif(SANITIZE STREQUAL "leak")
    set(CTEST_MEMORYCHECK_TYPE "LeakSanitizer")
    set(RUNTIME lsan)
  elseif(SANITIZE STREQUAL "memory")
    set(CTEST_MEMORYCHECK_TYPE "MemorySanitizer")
    set(RUNTIME msan)
  elseif(SANITIZE STREQUAL "thread")
    set(CTEST_MEMORYCHECK_TYPE "ThreadSanitizer")
    set(RUNTIME tsan)
  elseif(SANITIZE STREQUAL "undefined")
    set(CTEST_MEMORYCHECK_TYPE "UndefinedBehaviorSanitizer")
    list(APPEND CMAKE_CXX_FLAGS -fno-sanitize=vptr)
    set(OPTIONS print_stacktrace=1 halt_on_error=1)
    set(RUNTIME ubsan)
  endif()

  if(SANITIZE MATCHES "^(address|leak|memory|thread|undefined)$")
    string(APPEND CTEST_BUILD_NAME " [${CTEST_MEMORYCHECK_TYPE}]")
  else()
    string(APPEND CTEST_BUILD_NAME " [-fsanitize=${SANITIZE}]")
  endif()

  if(EXISTS "${CTEST_SOURCE_DIRECTORY}/.ci/${RUNTIME}.supp")
    list(APPEND OPTIONS suppressions=${CTEST_SOURCE_DIRECTORY}/.ci/${RUNTIME}.supp)
  endif()

  # If available, use the leak suppressions also when running the address sanitizer
  if(SANITIZE STREQUAL "address" AND EXISTS "${CTEST_SOURCE_DIRECTORY}/.ci/lsan.supp")
    set(ENV{LSAN_OPTIONS} "suppressions=${CTEST_SOURCE_DIRECTORY}/.ci/lsan.supp")
  endif()

  if(OPTIONS)
    string(JOIN "," OPTIONS ${OPTIONS})
    string(TOUPPER ${RUNTIME}_OPTIONS OPTIONS_VARIABLE)
    set(ENV{${OPTIONS_VARIABLE}} "${OPTIONS}")
    set(CTEST_MEMORYCHECK_SANITIZER_OPTIONS "${OPTIONS}")
  endif()

  # Sanitizer builds need more thread-local storage than usual, ask for more.
  # This is needed so that a program which is not instrumented (e.g. Python)
  # can load instrumented libraries without static TLS allocation failures.
  set(ENV{GLIBC_TUNABLES} "glibc.rtld.optional_static_tls=65536")

  if(COMPILER_ID MATCHES "Clang")
    execute_process(COMMAND ${COMPILER} -print-runtime-dir
      OUTPUT_VARIABLE RUNTIME_DIR OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)

    if(RUNTIME_DIR)
      get_filename_component(RUNTIME_DIR "${RUNTIME_DIR}" REALPATH)
    endif()

    if(IS_DIRECTORY "${RUNTIME_DIR}")
      message("Sanitizer runtime directory: ${RUNTIME_DIR}")
      foreach(TYPE EXE MODULE SHARED)
        list(PREPEND CMAKE_ARGS
          "-DCMAKE_${TYPE}_LINKER_FLAGS=-shared-libsan -Wl,-rpath,${RUNTIME_DIR}")
      endforeach()
    else()
      message(WARNING "Could not find the Clang runtime directory. Tests which "
                      "load the libraries into a program that is not "
                      "instrumented may fail.")
    endif()
  endif()

  set(IGNORELIST ${CTEST_SOURCE_DIRECTORY}/.ci/ignorelist.txt)

  if(COMPILER_ID MATCHES "Clang" AND EXISTS "${IGNORELIST}")
    list(APPEND CMAKE_C_FLAGS -fsanitize-ignorelist=${IGNORELIST})
    list(APPEND CMAKE_CXX_FLAGS -fsanitize-ignorelist=${IGNORELIST})
  endif()

  # Discover the tests just before they run, instead of during the build.
  # This matters with a sanitizer, since the build otherwise fails on
  # whatever the sanitizer finds while trying to discover the tests.
  list(PREPEND CMAKE_ARGS -DCMAKE_GTEST_DISCOVER_TESTS_DISCOVERY_MODE=PRE_TEST)
endif()

if(STATIC_ANALYSIS)
  string(APPEND CTEST_BUILD_NAME " [ClangTidy]")
  find_program(CMAKE_CXX_CLANG_TIDY NAMES clang-tidy)
  list(PREPEND CMAKE_ARGS "-DCMAKE_CXX_CLANG_TIDY=${CMAKE_CXX_CLANG_TIDY}")
endif()

string(JOIN " " CMAKE_C_FLAGS ${CMAKE_C_FLAGS})
string(JOIN " " CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})

list(PREPEND CMAKE_ARGS -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS})
list(PREPEND CMAKE_ARGS -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS})

set(CMAKE_ARGS $ENV{CMAKE_ARGS} ${CMAKE_ARGS})

if(DEFINED ENV{GITHUB_ACTIONS})
  set(CTEST_SITE "GitHub Actions ($ENV{GITHUB_REPOSITORY_OWNER})")

  if("$ENV{GITHUB_REPOSITORY_OWNER}" STREQUAL "xrootd")
    set(CDASH TRUE)
    set(MODEL "Continuous")
  endif()

  if("$ENV{GITHUB_EVENT_NAME}" MATCHES "pull_request")
    set(GROUP "Pull Requests")
    set(ENV{BASE_REF} $ENV{GITHUB_SHA}^1)
    set(ENV{HEAD_REF} $ENV{GITHUB_SHA}^2)
    string(REGEX REPLACE "/merge" "" CTEST_CHANGE_ID "$ENV{GITHUB_REF_NAME}")
    string(APPEND CTEST_BUILD_NAME " ($ENV{GITHUB_ACTOR}) #${CTEST_CHANGE_ID}")
  else()
    set(ENV{HEAD_REF} $ENV{GITHUB_SHA})
    string(APPEND CTEST_BUILD_NAME " ($ENV{GITHUB_REF_NAME})")
  endif()

  if("$ENV{GITHUB_RUN_ATTEMPT}" GREATER 1)
    string(APPEND CTEST_BUILD_NAME " #$ENV{GITHUB_RUN_ATTEMPT}")
  endif()

  message("::add-matcher::${CMAKE_CURRENT_LIST_DIR}/.github/matchers/gcc.json")

  macro(section title)
      message("::group::${title}")
  endmacro()

  macro(endsection)
      message("::endgroup::")
  endmacro()
else()
  macro(section title)
  endmacro()
  macro(endsection)
  endmacro()
endif()

if(NOT DEFINED CTEST_SITE)
  site_name(CTEST_SITE)
endif()

if(NOT DEFINED MODEL)
  if(DEFINED CTEST_SCRIPT_ARG)
    set(MODEL ${CTEST_SCRIPT_ARG})
  else()
    set(MODEL Experimental)
  endif()
endif()

if(NOT DEFINED GROUP)
  set(GROUP ${MODEL})
endif()

if(IS_DIRECTORY "${CTEST_BINARY_DIRECTORY}")
  ctest_empty_binary_directory("${CTEST_BINARY_DIRECTORY}")
endif()

ctest_read_custom_files("${CTEST_SOURCE_DIRECTORY}")

if(IS_DIRECTORY ${CTEST_SOURCE_DIRECTORY}/.git)
  find_program(CTEST_GIT_COMMAND NAMES git)
endif()

if(EXISTS "${CTEST_GIT_COMMAND}" AND DEFINED ENV{HEAD_REF} AND NOT DEFINED ENV{BASE_REF})
  set(CTEST_CHECKOUT_COMMAND
    "${CTEST_GIT_COMMAND} --git-dir ${CTEST_SOURCE_DIRECTORY}/.git checkout -f $ENV{HEAD_REF}")
endif()

section("Setup")
ctest_start(${MODEL} GROUP "${GROUP}")

if(EXISTS "${CTEST_GIT_COMMAND}")
  if(DEFINED ENV{BASE_REF})
    execute_process(COMMAND ${CTEST_GIT_COMMAND} checkout -f $ENV{BASE_REF}
      WORKING_DIRECTORY ${CTEST_SOURCE_DIRECTORY} ERROR_QUIET RESULT_VARIABLE GIT_STATUS)
    if(NOT ${GIT_STATUS} EQUAL 0)
      message(FATAL_ERROR "Could not checkout base ref: $ENV{BASE_REF}")
    endif()
  endif()
  if(DEFINED ENV{HEAD_REF})
    set(CTEST_GIT_UPDATE_CUSTOM
      ${CTEST_GIT_COMMAND} --git-dir ${CTEST_SOURCE_DIRECTORY}/.git checkout -f $ENV{HEAD_REF})
  else()
    set(CTEST_GIT_UPDATE_CUSTOM ${CTEST_GIT_COMMAND} --git-dir ${CTEST_SOURCE_DIRECTORY}/.git diff)
  endif()

  ctest_update()
endif()
endsection()

section("Configure")
foreach(FILENAME ${OS_NAME}${OS_VERSION}.cmake ${OS_NAME}.cmake config.cmake)
  if(EXISTS "${CTEST_SOURCE_DIRECTORY}/.ci/${FILENAME}")
    message("Using CMake cache file ${FILENAME}")
    list(PREPEND CMAKE_ARGS -C ${CTEST_SOURCE_DIRECTORY}/.ci/${FILENAME})
    list(APPEND CTEST_NOTES_FILES ${CTEST_SOURCE_DIRECTORY}/.ci/${FILENAME})
    break()
  endif()
endforeach()

ctest_configure(OPTIONS "${CMAKE_ARGS}" RETURN_VALUE CONFIG_RESULT)
ctest_read_custom_files("${CTEST_BINARY_DIRECTORY}")
list(APPEND CTEST_NOTES_FILES ${CTEST_BINARY_DIRECTORY}/CMakeCache.txt)
endsection()

if(${CONFIG_RESULT} EQUAL 0)
  section("Build")
  ctest_build(RETURN_VALUE BUILD_RESULT NUMBER_WARNINGS WARNINGS)
  endsection()
  if(WARNINGS GREATER 0)
    message(SEND_ERROR "Build contains compiler warnigns")
  endif()
else()
  message(SEND_ERROR "Configuration failed")
endif()

if(NOT ${BUILD_RESULT} EQUAL 0)
  message(SEND_ERROR "Build failed")
else()
  if(NOT DEFINED CTEST_MEMORYCHECK_TYPE)
    section("Test")
    ctest_test(RETURN_VALUE TEST_RESULT
      PARALLEL_LEVEL $ENV{CTEST_PARALLEL_LEVEL})
    endsection()
  else()
    section("${CTEST_MEMORYCHECK_TYPE}")
    ctest_memcheck(RETURN_VALUE TEST_RESULT
      PARALLEL_LEVEL $ENV{CTEST_PARALLEL_LEVEL})
    endsection()
  endif()

  if(NOT ${TEST_RESULT} EQUAL 0)
    message(SEND_ERROR "Tests failed")
  endif()

  if(DEFINED CTEST_COVERAGE_COMMAND)
    section("Coverage")
    find_program(GCOVR NAMES gcovr)
    if(EXISTS ${GCOVR})
      execute_process(COMMAND
        ${GCOVR} --gcov-executable ${CTEST_COVERAGE_COMMAND}
          -r ${CTEST_SOURCE_DIRECTORY} ${CTEST_BINARY_DIRECTORY}
          --gcov-ignore-parse-errors negative_hits.warn
          --html-details ${CTEST_BINARY_DIRECTORY}/coverage/ ERROR_VARIABLE ERROR)
      if(ERROR)
        message(SEND_ERROR "Failed to generate coverage report:\n${ERROR}")
      endif()
    endif()
    ctest_coverage()
    endsection()
  endif()

  if(INSTALL)
    section("Install")
    set(ENV{DESTDIR} "${CTEST_BINARY_DIRECTORY}/install")
    ctest_build(TARGET install)
    endsection()
  endif()
endif()

if(CDASH OR (DEFINED ENV{CDASH} AND "$ENV{CDASH}"))
  ctest_submit(
    BUILD_ID BUILDID
    RETRY_COUNT 3
    RETRY_DELAY 5
    RETURN_VALUE SUBMIT_RESULT
    CAPTURE_CMAKE_ERROR SUBMIT_ERROR
    QUIET)

  if(NOT SUBMIT_RESULT EQUAL 0 OR NOT SUBMIT_ERROR EQUAL 0)
    message(WARNING "CDash submission failed")
  else()
    message("CDash URL: https://my.cdash.org/index.php?project=XRootD")
    if(BUILDID)
      message("Build result URL: https://my.cdash.org/builds/${BUILDID}")
    endif()
  endif()
endif()