CMake e CTest: make test non crea test

Sto provando CTest in CMake per eseguire automaticamente alcuni dei miei test utilizzando make testtarget. Il problema è che CMake non "capisce" che il test che sono disposto a eseguire deve essere compilato poiché fa parte del progetto.

Quindi sto cercando un modo per specificare esplicitamente questa dipendenza.

È senza dubbio un bug in CMake (precedentemente tracciato qui ) che questo non funziona immediatamente. Una soluzione alternativa è eseguire le seguenti operazioni:

add_test(TestName ExeName)
add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND}
                  DEPENDS ExeName)

Quindi puoi eseguire make checke compilerà ed eseguirà il test. Se hai diversi test, dovresti usare DEPENDS exe1 exe2 exe3 ...nella riga sopra.

In realtà c'è un modo per usare make test. È necessario definire la build dell'eseguibile di test come uno dei test e quindi aggiungere le dipendenze tra i test. Questo è:

ADD_TEST(ctest_build_test_code
         "${CMAKE_COMMAND}" --build ${CMAKE_BINARY_DIR} --target test_code)
ADD_TEST(ctest_run_test_code test_code)
SET_TESTS_PROPERTIES(ctest_run_test_code
                     PROPERTIES DEPENDS ctest_build_test_code)

Uso una variante della risposta di richq. Nel livello superiore CMakeLists.txt, aggiungo un target personalizzato,, build_and_testper la creazione e l'esecuzione di tutti i test:

find_package(GTest)
if (GTEST_FOUND)
    enable_testing()
    add_custom_target(build_and_test ${CMAKE_CTEST_COMMAND} -V)
    add_subdirectory(test)
endif()

Nei vari CMakeLists.txtfile di sottoprogetto sotto test/, aggiungo ogni eseguibile di test come dipendenza di build_and_test:

include_directories(${CMAKE_SOURCE_DIR}/src/proj1)
include_directories(${GTEST_INCLUDE_DIRS})
add_executable(proj1_test proj1_test.cpp)
target_link_libraries(proj1_test ${GTEST_BOTH_LIBRARIES} pthread)
add_test(proj1_test proj1_test)
add_dependencies(build_and_test proj1_test)

Con questo approccio, ho solo bisogno make build_and_testdi make test(o make all test), e ha il vantaggio di creare solo codice di test (e le sue dipendenze). È un peccato non poter usare il nome del bersaglio test. Nel mio caso, non è così male perché ho uno script di primo livello che esegue il debug e il rilascio fuori dall'albero (e le compilazioni incrociate) chiamando cmakee poi make, e si traduce testin build_and_test.

Ovviamente, la roba GTest non è richiesta. Mi è capitato di usare / come Google Test e volevo condividere un esempio completo di utilizzo con CMake / CTest. IMHO, questo approccio ha anche il vantaggio di consentirmi di utilizzare ctest -V, che mostra l'output di Google Test durante l'esecuzione dei test:

1: Running main() from gtest_main.cc
1: [==========] Running 1 test from 1 test case.
1: [----------] Global test environment set-up.
1: [----------] 1 test from proj1
1: [ RUN      ] proj1.dummy
1: [       OK ] proj1.dummy (0 ms)
1: [----------] 1 test from proj1 (1 ms total)
1:
1: [----------] Global test environment tear-down
1: [==========] 1 test from 1 test case ran. (1 ms total)
1: [  PASSED  ] 1 test.
1/2 Test #1: proj1_test .......................   Passed    0.03 sec

Se stai cercando di emulare make check, potresti trovare utile questa voce wiki:

http://www.cmake.org/Wiki/CMakeEmulateMakeCheck

Ho appena verificato che fa quello che dice con successo (CMake 2.8.10).

Risparmia il mal di testa:

make all test

Per me funziona immediatamente e creerà dipendenze prima di eseguire il test. Dato quanto sia semplice, rende quasi make testconveniente la funzionalità nativa perché ti dà la possibilità di eseguire gli ultimi test di compilazione anche se il tuo codice è rotto.

Se stai usando CMake> = 3.7, l'approccio consigliato è usare i dispositivi :

add_executable(test test.cpp)
add_test(test_build
  "${CMAKE_COMMAND}"
  --build "${CMAKE_BINARY_DIR}"
  --config "$<CONFIG>"
  --target test
)
set_tests_properties(test_build PROPERTIES FIXTURES_SETUP    test_fixture)
add_test(test test)
set_tests_properties(test       PROPERTIES FIXTURES_REQUIRED test_fixture)

Questo fa quanto segue:

• Aggiunge una testdestinazione eseguibile costruita datest.cpp
• Aggiunge un test_build"test" che esegue Cmake per costruire il targettest
• Contrassegna il test_buildtest come un'attività di configurazione del dispositivotest_fixture
• Aggiungi un testtest che esegue solo l' testeseguibile
• Contrassegna il testtest per aver bisogno del dispositivo test_fixture.

Quindi, ogni volta che testdeve essere eseguito test test_build, esegue prima test , che crea l'eseguibile necessario.

Questo è ciò che ho elaborato e ho utilizzato:

set(${PROJECT_NAME}_TESTS a b c)

enable_testing()
add_custom_target(all_tests)
foreach(test ${${PROJECT_NAME}_TESTS})
        add_executable(${test} EXCLUDE_FROM_ALL ${test}.cc)
        add_test(NAME ${test} COMMAND $<TARGET_FILE:${test}>)
        add_dependencies(all_tests ${test})
endforeach(test)

build_command(CTEST_CUSTOM_PRE_TEST TARGET all_tests)
string(CONFIGURE \"@CTEST_CUSTOM_PRE_TEST@\" CTEST_CUSTOM_PRE_TEST_QUOTED ESCAPE_QUOTES)
file(WRITE "${CMAKE_BINARY_DIR}/CTestCustom.cmake" "set(CTEST_CUSTOM_PRE_TEST ${CTEST_CUSTOM_PRE_TEST_QUOTED})" "\n")

YMMV

La risposta di Derrick, semplificata e commentata:

# It is impossible to make target "test" depend on "all":
# https://gitlab.kitware.com/cmake/cmake/-/issues/8774
# Set a magic variable in a magic file that tells ctest
# to invoke the generator once before running the tests:
file(WRITE "${CMAKE_BINARY_DIR}/CTestCustom.cmake"
    "set(CTEST_CUSTOM_PRE_TEST ${CMAKE_MAKE_PROGRAM})\n"
)

Non è perfettamente corretto, in quanto non risolve il problema della concorrenza dell'esecuzione ninja all test, nel caso qualcuno lo facesse. Al contrario, perché ora hai due processi ninja.

(Ftr, ho anche condiviso questa soluzione qui .)

Tutte le risposte di cui sopra sono perfette. Ma in realtà CMake usa CTest come strumento di test, quindi il metodo standard (penso che sia) per svolgere la missione è:

enable_testing ()
add_test (TestName TestCommand)
add_test (TestName2 AnotherTestCommand)

Quindi esegui cmake e make per costruire i bersagli. Dopodiché, puoi eseguire make test o semplicemente eseguire

ctest

otterrai il risultato. Questo è testato con CMake 2.8.

Controlla i dettagli su: http://cmake.org/Wiki/CMake/Testing_With_CTest#Simple_Testing

Tutte le risposte sono buone, ma implicano una violazione della tradizione per eseguire un test per comando make test. Ho fatto questo trucco:

add_test(NAME <mytest>
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
COMMAND sh -c "make <mytarget>; $<TARGET_FILE:<mytarget>>")

Ciò significa che il test consiste nella creazione (facoltativamente) e nell'esecuzione di un target eseguibile.