Come rendere le DLL Boost accessibili a un eseguibile creato con CMake?

Question

Sto usando CMake su Windows per creare una suite di test basata su Boost.Test. Poiché sto collegando dinamicamente Boost.Test, il mio eseguibile deve essere in grado di trovare la DLL (che si trova in ../../../boost/boost_1_47/lib o qualcosa del genere relativo all'eseguibile).

Così ho bisogno di copiare la DLL nella cartella in cui l'eseguibile è, o renderlo trovabili in qualche altro modo. Qual è il modo migliore per ottenere questo risultato con CMake?

- Ulteriori informazioni -

mio CMakeLists.txt ha questo Boost configurazione relative al momento:

set(Boost_ADDITIONAL_VERSIONS "1.47" "1.47.0") 
set(BOOST_ROOT "../boost") 

find_package(Boost 1.47 COMPONENTS unit_test_framework REQUIRED) 
include_directories(${Boost_INCLUDE_DIR}) 
link_directories(${Boost_LIBRARY_DIR}) 

add_executable(test-suite test-suite.cpp) 
target_link_libraries(test-suite ${Boost_LIBRARIES}) 

Answer 1

ho finito per usare il comando install per copiare la DLL Boost verso la cartella del file eseguibile:

get_filename_component(UTF_BASE_NAME ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY_RELEASE} NAME_WE) 
get_filename_component(UTF_PATH ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY_RELEASE} PATH) 
install(FILES ${UTF_PATH}/${UTF_BASE_NAME}.dll 
    DESTINATION ../bin 
    CONFIGURATIONS Release RelWithDebInfo 
) 

get_filename_component(UTF_BASE_NAME_DEBUG ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY_DEBUG} NAME_WE) 
install(FILES ${UTF_PATH}/${UTF_BASE_NAME_DEBUG}.dll 
    DESTINATION ../bin 
    CONFIGURATIONS Debug 
) 

Answer 2

Supponendo che si sta eseguendo i test con la costruzione del bersaglio RUN_TESTS in Visual Studio:

1. Aggiungo sempre .../boost/boost_1_47/lib al mio comando variabile di ambiente PATH, quindi è possibile trovare le DLL unit_test_framework di boost in fase di esecuzione. Questo è quello che raccomando.

2. Se per qualche ragione modifica del PATH non è possibile, si potrebbe copiare i file con CMake.

(non testato)

get_filename_component(LIBNAME "${Boost_UNIT_TEST_FRAMEWORK_LIBRARY_RELEASE}" NAME) 
add_custom_command(TARGET test-suite POST_BUILD 
    COMMAND ${CMAKE_COMMAND} -E copy "${Boost_UNIT_TEST_FRAMEWORK_LIBRARY_RELEASE}" "${CMAKE_CURRENT_BINARY_DIR}/${LIBNAME}" 
) 

3. Se siete NON solo eseguire i test in fase di costruzione (come mi è stato presupposto sopra), allora avete bisogno di una serie di comandi INSTALL, come Suggerì Hans Passant. Nel tuo snippet non hai un comando INSTALL per il tuo eseguibile; così anche il tuo eseguibile non finirà "nella cartella eseguibile". Innanzitutto aggiungi un comando cmake INSTALL per mettere il tuo eseguibile da qualche parte in risposta al target cmake INSTALL. Una volta che hai funzionato, possiamo lavorare su come aggiungere un altro comando INSTALL per mettere la libreria boost unit_test_framework nella stessa posizione. Dopodiché, se vuoi creare un programma di installazione usando CPACK, la libreria verrà automaticamente installata con l'eseguibile.

Answer 3

Ho un problema molto simile, ma la soluzione qui presentata non è davvero soddisfacente. Come il poster originale, voglio eseguire test unitari basati su boost :: test.

ho più progetti di test, uno per ogni componente il sindaco del nostro prodotto. Dovendo eseguire la destinazione dell'installazione prima di ogni test, è necessario ricompilare tutto per eseguire i test appartenenti a un componente principale. Questo è quello che voglio evitare.

Se cambio qualcosa in un componente fondamentale, voglio compilare tale componente core e le relative prove. E poi esegui i test. Quando i test hanno successo, solo allora voglio compilare ed eventualmente installare il resto.

Per eseguire i test nel debugger, ho trovato alcuni script cmake molto utile a: https://github.com/rpavlik/cmake-modules

Con questo, posso specificare tutte le directory delle DLL necessarie, e la variabile d'ambiente PATH è impostato per la nuovo processo:

# for debugging 
INCLUDE(CreateLaunchers) 

create_target_launcher(PLCoreTests 
    ARGS "--run-test=Core1" 
    RUNTIME_LIBRARY_DIRS ${PL_RUNTIME_DIRS_DEBUG} ${PROJECT_BINARY_DIR}/bin/Debug 
    WORKING_DIRECTORY ${PL_MAIN_DIR}/App/PL/bin 
) 

dove $ {} PL_RUNTIME_DIRS_DEBUG contiene le directory in cui le DLL di spinta e tutte le altre librerie possono essere trovati.

Ora sto cercando come posso ottenere qualcosa di simile con ADD_CUSTOM_COMMAND()

Aggiornamento:

ADD_CUSTOM_COMMAND() può avere più comandi che CMake scrive in un file batch. Quindi, è possibile innanzitutto impostare il percorso con tutte le directory di runtime e quindi eseguire il test eseguibile. Per essere in grado di eseguire facilmente i test manualmente, ho lasciato cmake creare un file batch aggiuntivo nella directory di compilazione:

MACRO(RunUnitTest TestTargetName) 
    IF(RUN_UNIT_TESTS) 
     SET(TEMP_RUNTIME_DIR ${PROJECT_BINARY_DIR}/bin/Debug) 
     FOREACH(TmpRuntimeDir ${PL_RUNTIME_DIRS_DEBUG}) 
      SET(TEMP_RUNTIME_DIR ${TEMP_RUNTIME_DIR} ${TmpRuntimeDir}) 
     ENDFOREACH(TmpRuntimeDir) 

     ADD_CUSTOM_COMMAND(TARGET ${TestTargetName} POST_BUILD 
      COMMAND echo "PATH=${TEMP_RUNTIME_DIR};%PATH%" > ${TestTargetName}_script.bat 
      COMMAND echo ${TestTargetName}.exe --result_code=no --report_level=no >> ${TestTargetName}_script.bat 
      COMMAND ${TestTargetName}_script.bat 
      WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/Debug 
     ) 
    ENDIF(RUN_UNIT_TESTS) 
ENDMACRO() 

Con questo, i test di unità cattura gli errori nel più breve tempo possibile, senza dover compilare l'intero molto prima