¿Cómo hacer que Boost DLL sea accesible para un archivo ejecutable creado con CMake?

Question

Estoy usando CMake en Windows para construir un conjunto de pruebas basado en Boost.Test. Como me estoy vinculando a Boost.Test dinámicamente, mi ejecutable debe ser capaz de encontrar el archivo DLL (que está bajo ../../../boost/boost_1_47/lib o algo así en relación con el ejecutable).

Así que necesito copiar el archivo DLL en la carpeta donde está el ejecutable, o hacer que se pueda encontrar de alguna otra manera. ¿Cuál es la mejor manera de lograr esto con CMake?

- Otros detalles -

Mi CMakeLists.txt Boost tiene esta configuración relacionada en la actualidad

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

Terminé usando el comando install copiar el archivo DLL Impulso a la carpeta del ejecutable:

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

Suponiendo que está ejecutando sus pruebas mediante la construcción de la meta RUN_TESTS en Visual Studio:

1. Siempre agrego .../boost/boost_1_47/lib a mi comando Variable de entorno PATH, por lo que las unidades boost boost_test_framework dlls se pueden encontrar en tiempo de ejecución. Eso es lo que recomiendo

2. Si por alguna razón no es posible cambiar la RUTA, puede copiar los archivos con cmake.

(no probado)

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. Si usted es NO solamente ejecutar las pruebas en tiempo de compilación (como yo estaba asumiendo más arriba), entonces necesita una serie de comandos INSTALL, como Hans Passant sugirió. En su fragmento no tiene un comando INSTALL para su ejecutable; por lo que incluso su ejecutable no terminará "en la carpeta ejecutable". Primero agregue un comando cmake INSTALL para colocar su ejecutable en algún lugar en respuesta al objetivo cMAke INSTALL. Una vez que tenga eso funcionando, podemos trabajar para descubrir cómo agregar otro comando INSTALL para colocar la biblioteca boost unit_test_framework en la misma ubicación. Después de eso, si desea crear un instalador usando CPACK, la biblioteca se instalará automáticamente con el ejecutable.

Answer 3

Tengo un problema muy similar, pero la solución que aquí se presenta no es realmente satisfactoria. Al igual que el póster original, quiero ejecutar pruebas unitarias basadas en boost :: test.

Tengo varios proyectos de prueba, uno para cada componente principal de nuestro producto. Tener que ejecutar el objetivo de instalación antes de cada prueba significa recompilarlo todo solo para ejecutar las pruebas que pertenecen a un componente central. Eso es lo que quiero evitar.

Si cambio algo en un componente central, quiero compilar ese componente principal y las pruebas asociadas. Y luego ejecuta las pruebas. Cuando las pruebas tienen éxito, solo entonces quiero compilar y eventualmente instalar el resto.

Para ejecutar las pruebas en el depurador, me encontré con algunos scripts cmake muy útiles en: https://github.com/rpavlik/cmake-modules

Con esto, se pueden especificar todos los directorios de los archivos .DLL necesarios, y la variable de entorno PATH se establece para el nuevo proceso:

# 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 
) 

donde $ {} PL_RUNTIME_DIRS_DEBUG contiene los directorios donde los archivos DLL de impulso y todas las otras bibliotecas se pueden encontrar.

Ahora estoy buscando la forma en que puedo lograr algo similar con ADD_CUSTOM_COMMAND()

Actualización:

ADD_CUSTOM_COMMAND() puede tener varios comandos que cmake escribe en un archivo por lotes. Entonces, primero puede establecer la ruta con todos los directorios de tiempo de ejecución y luego ejecutar el ejecutable de prueba. Para poder ejecutar fácilmente las pruebas de forma manual, dejo que cmake crear un archivo por lotes adicional en el directorio de construcción:

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 esto, las pruebas unitarias atrapan los errores tan pronto como sea posible, sin tener que compilar el conjunto mucho primero