DD4hepBuild.cmake

  cmake_parse_arguments(ARG "" "" "SOURCES;EXCLUDE;LINKDEF;OPTIONS" ${ARGN} )
  get_property(pkg DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY PACKAGE_NAME)
  set ( tag "Dictionary[${pkg}] -> ${dictionary}" )
  message( STATUS "|++> ${tag} Building dictionary ..." ) 
  if("${ARG_LINKDEF}" STREQUAL "")
    set(ARG_LINKDEF "${CMAKE_SOURCE_DIR}/DDCore/include/ROOT/LinkDef.h")
  endif()
  #
  file( GLOB headers ${ARG_SOURCES} )
  file( GLOB excl_headers ${ARG_EXCLUDE} )
  foreach( f ${excl_headers} )
    list( REMOVE_ITEM headers ${f} )
    message( STATUS "|++        exclude: ${f}" )
  endforeach()
  #
  get_property(incs DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY PACKAGE_INCLUDE_DIRS)
  get_property(defs DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY COMPILE_DEFINITIONS)
  get_property(opts DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY COMPILE_OPTIONS)
  #
  set ( inc_dirs -I${CMAKE_CURRENT_SOURCE_DIR}/include )
  foreach ( inc ${incs} )
    file ( GLOB inc ${inc} )
    set ( inc_dirs ${inc_dirs} -I${inc} )
  endforeach()
  #
  file ( GLOB linkdefs ${ARG_LINKDEF} )
  #
  set ( comp_defs )
  foreach ( def ${defs} )
    set ( comp_defs ${comp_defs} -D${def} )
  endforeach()
  #
  dd4hep_make_unique_list ( sources   VALUES ${headers} )
  dd4hep_make_unique_list ( linkdefs  VALUES ${linkdefs} )
  dd4hep_make_unique_list ( inc_dirs  VALUES ${inc_dirs} )
  dd4hep_make_unique_list ( comp_defs VALUES ${comp_defs} )
  #
  dd4hep_debug ( "${tag}  Linkdef: '${linkdefs}'" ) 
  dd4hep_debug ( "${tag}  Compile: '${comp_defs};${inc_dirs}'" ) 
  dd4hep_debug ( "${tag}  Files:   '${headers}'" ) 
  dd4hep_debug ( "${tag}  Unparsed:'${ARG_UNPARSED_ARGUMENTS}'" ) 
  dd4hep_debug ( "${tag}  Sources: '${CMAKE_CURRENT_SOURCE_DIR}'" ) 
  #
  add_custom_command(OUTPUT ${dictionary}.cxx ${dictionary}.h
    COMMAND ${ROOTCINT_EXECUTABLE} -f  ${dictionary}.cxx 
            -c -p ${ARG_OPTIONS} ${comp_defs} ${inc_dirs} ${headers} ${linkdefs} 
    DEPENDS ${headers} ${linkdefs} )
endfunction()


#---------------------------------------------------------------------------------------------------
macro ( dd4hep_configure_scripts _pkg )
  cmake_parse_arguments(MACRO_ARG "DEFAULT_SETUP;WITH_TESTS" "RUN_SCRIPT" "" ${ARGV} )
  message ( STATUS "|++> Setting up test environment: ${ARGV}" )
  set( PackageName ${_pkg} )
  if ( ${MACRO_ARG_DEFAULT_SETUP} )
    configure_file( ${DD4hep_DIR}/cmake/run_test_package.sh ${EXECUTABLE_OUTPUT_PATH}/run_test_${_pkg}.sh @ONLY)
    INSTALL(PROGRAMS ${EXECUTABLE_OUTPUT_PATH}/run_test_${_pkg}.sh DESTINATION bin )
    #---- configure run environment ---------------
    configure_file( ${DD4hep_DIR}/cmake/thisdd4hep_package.sh.in  ${EXECUTABLE_OUTPUT_PATH}/this${_pkg}.sh @ONLY)
    install(PROGRAMS ${EXECUTABLE_OUTPUT_PATH}/this${_pkg}.sh DESTINATION bin )
    #--- install target-------------------------------------
    if ( IS_DIRECTORY scripts )
      dd4hep_install_dir ( compact scripts DESTINATION examples/${_pkg} )
    endif()
    if (IS_DIRECTORY compact )
      dd4hep_install_dir ( compact DESTINATION examples/${_pkg} )
    endif()
  endif()
  if ( ${MACRO_ARG_WITH_TESTS} ) 
    if ( BUILD_TESTING )
      include(CTest)
      enable_testing ()
      if ( NOT "${MACRO_ARG_UPARSED_ARGUMENTS}" STREQUAL "" )
        foreach ( dir ${MACRO_ARG_UPARSED_ARGUMENTS} )
          add_subdirectory ( ${dir} )
        endforeach()
      endif()
    endif(BUILD_TESTING)
    set ( BUILDNAME "${CMAKE_SYSTEM}-${CMAKE_CXX_COMPILER}-${CMAKE_BUILD_TYPE}" CACHE STRING "set build string for cdash")
  endif()
  unset( PackageName )
endmacro( dd4hep_configure_scripts )

#---------------------------------------------------------------------------------------------------
#
#  \author  M.Frank
#  \version 1.0
#
#---------------------------------------------------------------------------------------------------
macro( dd4hep_enable_tests )
  cmake_parse_arguments(MACRO_ARG "" "" "" ${ARGV} )
  #message ( "***|++> Test environment: BUILD_TESTING:${BUILD_TESTING} DIRS:${MACRO_ARG_UNPARSED_ARGUMENTS}" )
  if (BUILD_TESTING)
    message ( "***|++> Enable CTest environment....BUILD:${BUILD_TESTING} DIRS:${MACRO_ARG_UNPARSED_ARGUMENTS}" )
    include(CTest)
    enable_testing ()
    if ( NOT "${MACRO_ARG_UNPARSED_ARGUMENTS}" STREQUAL "" )
      foreach ( _dir ${MACRO_ARG_UNPARSED_ARGUMENTS} )
        add_subdirectory ( ${_dir} )
      endforeach()
    endif()
  endif()
  set ( BUILDNAME "${CMAKE_SYSTEM}-${CMAKE_CXX_COMPILER}-${CMAKE_BUILD_TYPE}" CACHE STRING "set build string for cdash")
endmacro( dd4hep_enable_tests )

#---------------------------------------------------------------------------------------------------
#  dd4hep_add_test_reg
#
#  Add test with regular expression output parsing.
#  BUILD_EXEC:  Add and build executable with the same name as the test (Default NONE)
#  OUTPUT       Output file of the test (Default: empty)
#  COMMAND      Command to execute
#  EXEC_ARGS    Arguments to the command
#  REGEX_PASS   Regular expression to indicate that the test succeeded
#  REGEX_FAIL   Regular expression to indicate that the test failed
#
#  \author  M.Frank
#  \version 1.0
#
#---------------------------------------------------------------------------------------------------
function ( dd4hep_add_test_reg test_name )
  cmake_parse_arguments(ARG "BUILD_EXEC" "OUTPUT" "COMMAND;EXEC_ARGS;REGEX_PASS;REGEX_PASSED;REGEX_FAIL;REGEX_FAILED" ${ARGN} )
  if ( ${ARG_BUILD_EXEC} )
    #message(STATUS "Building executable:  ${test_name} SOURCES src/${test_name}.cc")
    dd4hep_add_executable ( ${test_name} SOURCES src/${test_name}.cc )
  endif()

  set ( cmd ${ARG_COMMAND} )
  if ( "${cmd}" STREQUAL "" )
    set ( cmd ${CMAKE_INSTALL_PREFIX}/bin/run_test.sh ${test_name} )
  endif()

  set ( passed ${ARG_REGEX_PASS} ${ARG_REGEX_PASSED} )
  if ( "${passed}" STREQUAL "NONE" )
    unset ( passed )
  elseif ( "${passed}" STREQUAL "" )
    set ( passed "TEST_PASSED" )
  endif()

  set ( failed ${ARG_REGEX_FAIL} ${ARG_REGEX_FAILED} )
  if ( "${failed}" STREQUAL "NONE" )
    unset ( failed )
  endif()
  set ( output ${ARG_OUTPUT} )

  set ( args ${ARG_EXEC_ARGS} )
  if ( "${args}" STREQUAL "" )
    set ( args ${test_name} )
  endif()
  add_test(NAME t_${test_name} COMMAND ${cmd} ${output} ${args} ${output} )
  if ( NOT "${passed}" STREQUAL "" )
    set_tests_properties( t_${test_name} PROPERTIES PASS_REGULAR_EXPRESSION "${passed}" )
  endif()
  if ( NOT "${failed}" STREQUAL "" )
    set_tests_properties( t_${test_name} PROPERTIES FAIL_REGULAR_EXPRESSION "${failed}" )
  endif()
endfunction()