So beginnen Sie mit GTest und CMake zu arbeiten

Vor kurzem wurde mir die Verwendung von CMake zum Kompilieren meiner C ++ - Projekte verkauft, und ich möchte jetzt einige Komponententests für meinen Code schreiben. Ich habe mich entschieden, das Google Test-Dienstprogramm zu verwenden, um dies zu unterstützen, benötige jedoch Hilfe beim Einstieg.

Den ganzen Tag habe ich verschiedene Anleitungen und Beispiele gelesen, darunter den Primer , eine Einführung bei IBM und einige Fragen zu SO ( hier und hier ) sowie andere Quellen, die ich aus den Augen verloren habe. Mir ist klar, dass es da draußen viel gibt, aber irgendwie habe ich immer noch Schwierigkeiten.

Ich versuche derzeit, den grundlegendsten Test zu implementieren, um zu bestätigen, dass ich gtest richtig kompiliert / installiert habe und es nicht funktioniert. Die einzige Quelldatei (testgtest.cpp) stammt fast genau aus dieser vorherigen Antwort:

#include <iostream>

#include "gtest/gtest.h"

TEST(sample_test_case, sample_test)
{
    EXPECT_EQ(1, 1);
}

und meine zugehörige CMakeLists.txt lautet wie folgt:

cmake_minimum_required(VERSION 2.6)
project(basic_test)

# Setup testing
enable_testing()
find_package(GTest REQUIRED)
include_directories(${GTEST_INCLUDE_DIR})

# Add test cpp file
add_executable(runUnitTests
    testgtest.cpp
)

# Link test executable against gtest & gtest_main
target_link_libraries(runUnitTests ${GTEST_LIBRARY_DEBUG} ${GTEST_MAIN_LIBRARY_DEBUG})

add_test(
    NAME runUnitTests
    COMMAND runUnitTests
)

Beachten Sie, dass ich mich dafür entschieden habe, eine Verknüpfung mit gtest_main herzustellen, anstatt die Hauptdatei am Ende der CPP-Datei anzugeben, da ich glaube, dass ich dadurch das Testen einfacher auf mehrere Dateien skalieren kann.

Beim Erstellen der generierten SLN-Datei (in Visual C ++ 2010 Express) wird leider eine lange Liste von Fehlern des Formulars angezeigt

2>msvcprtd.lib(MSVCP100D.dll) : error LNK2005: "public: virtual __thiscall std::basic_iostream<char,struct std::char_traits<char> >::~basic_iostream<char,struct std::char_traits<char> >(void)" (??1?$basic_iostream@DU?$char_traits@D@std@@@std@@UAE@XZ) already defined in gtestd.lib(gtest-all.obj)

was meiner Meinung nach bedeutet, dass ich nicht erfolgreich auf die gtest-Bibliotheken verlinke. Ich habe sichergestellt, dass ich beim Verknüpfen mit den Debug-Bibliotheken versucht habe, im Debug-Modus zu erstellen.

BEARBEITEN

Nachdem ich noch ein bisschen gegraben habe, denke ich, dass mein Problem etwas mit der Art der Bibliothek zu tun hat, in die ich gtest einbaue. Wenn beim Erstellen von gtest mit CMake das BUILD_SHARED_LIBSKontrollkästchen deaktiviert ist und ich mein Programm mit diesen .lib-Dateien verknüpfe, werden die oben genannten Fehler angezeigt . Wenn dies BUILD_SHARED_LIBSjedoch aktiviert ist, erstelle ich eine Reihe von .lib- und .dll-Dateien. Beim Verknüpfen mit diesen .lib-Dateien wird das Programm kompiliert, beim Ausführen wird jedoch beanstandet, dass es gtest.dll nicht finden kann.

Was sind die Unterschiede zwischen einer SHAREDund einer Nicht- SHAREDBibliothek, und wenn ich nicht freigegeben wähle, warum funktioniert es nicht? Gibt es in der CMakeLists.txt eine Option für mein Projekt, die mir fehlt?

Die Lösung bestand darin, das Quellverzeichnis gtest als Unterverzeichnis Ihres Projekts zu speichern. Ich habe die funktionierende CMakeLists.txt unten eingefügt, wenn sie für jemanden hilfreich ist.

cmake_minimum_required(VERSION 2.6)
project(basic_test)

################################
# GTest
################################
ADD_SUBDIRECTORY (gtest-1.6.0)
enable_testing()
include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})

################################
# Unit Tests
################################
# Add test cpp file
add_executable( runUnitTests testgtest.cpp )
# Link test executable against gtest & gtest_main
target_link_libraries(runUnitTests gtest gtest_main)
add_test( runUnitTests runUnitTests )

Hier ist ein vollständiges Arbeitsbeispiel, das ich gerade getestet habe. Es wird direkt aus dem Internet heruntergeladen, entweder ein fester Tarball oder das neueste Subversion-Verzeichnis.

cmake_minimum_required (VERSION 3.1)

project (registerer)

##################################
# Download and install GoogleTest

include(ExternalProject)
ExternalProject_Add(gtest
  URL https://googletest.googlecode.com/files/gtest-1.7.0.zip
  # Comment above line, and uncomment line below to use subversion.
  # SVN_REPOSITORY http://googletest.googlecode.com/svn/trunk/ 
  # Uncomment line below to freeze a revision (here the one for 1.7.0)
  # SVN_REVISION -r700

  PREFIX ${CMAKE_CURRENT_BINARY_DIR}/gtest
  INSTALL_COMMAND ""
)
ExternalProject_Get_Property(gtest source_dir binary_dir)

################
# Define a test
add_executable(registerer_test registerer_test.cc)

######################################
# Configure the test to use GoogleTest
#
# If used often, could be made a macro.

add_dependencies(registerer_test gtest)
include_directories(${source_dir}/include)
target_link_libraries(registerer_test ${binary_dir}/libgtest.a)
target_link_libraries(registerer_test ${binary_dir}/libgtest_main.a)

##################################
# Just make the test runnable with
#   $ make test

enable_testing()
add_test(NAME    registerer_test 
         COMMAND registerer_test)

Sie können das Beste aus beiden Welten bekommen. Es ist möglich, ExternalProjectdie gtest-Quelle herunterzuladen und dann add_subdirectory()zu Ihrem Build hinzuzufügen. Dies hat folgende Vorteile:

• gtest wird als Teil Ihres Haupt-Builds erstellt, verwendet also dieselben Compiler-Flags usw. und vermeidet so Probleme wie die in der Frage beschriebenen.
• Sie müssen die gtest-Quellen nicht zu Ihrem eigenen Quellbaum hinzufügen.

Bei normaler Verwendung führt ExternalProject das Herunterladen und Entpacken nicht zum Zeitpunkt der Konfiguration durch (dh wenn CMake ausgeführt wird), aber Sie können dies mit ein wenig Arbeit erreichen. Ich habe einen Blog-Beitrag darüber geschrieben, der auch eine allgemeine Implementierung enthält, die für jedes externe Projekt funktioniert, das CMake als Build-System verwendet, nicht nur für gtest. Sie finden sie hier:

• https://crascit.com/2015/07/25/cmake-gtest/
• https://github.com/Crascit/DownloadProject

Update: Dieser Ansatz ist jetzt auch Teil der Googletest-Dokumentation .

Der Unterschied in den Compileroptionen zwischen Ihrer Testbinärdatei und der Google Testbibliothek ist höchstwahrscheinlich auf solche Fehler zurückzuführen. Aus diesem Grund wird empfohlen, Google Test im Quellformular einzubringen und zusammen mit Ihren Tests zu erstellen. In CMake ist das sehr einfach. Sie rufen einfach ADD_SUBDIRECTORYmit dem Pfad zum gtest-Stamm auf und können dann die dort definierten Ziele ( gtestund gtest_main) der öffentlichen Bibliothek verwenden . In diesem CMake-Thread in der Gruppe googletestframework finden Sie weitere Hintergrundinformationen .

[Bearbeiten] Die BUILD_SHARED_LIBSOption ist derzeit nur unter Windows wirksam. Es gibt den Typ der Bibliotheken an, die CMake erstellen soll. Wenn Sie dies festlegen ON, erstellt CMake sie als DLLs im Gegensatz zu statischen Bibliotheken. In diesem Fall müssen Sie Ihre Tests mit -DGTEST_LINKED_AS_SHARED_LIBRARY = 1 erstellen und die vom CMake erstellten DLL-Dateien mit Ihrer Testbinärdatei in das Verzeichnis kopieren (CMake legt sie standardmäßig in einem separaten Ausgabeverzeichnis ab). Wenn gtest in der statischen Bibliothek nicht für Sie funktioniert, ist es einfacher, diese Option nicht festzulegen.

Nachdem ich noch ein bisschen gegraben habe, denke ich, dass mein Problem etwas mit der Art der Bibliothek zu tun hat, in die ich gtest einbaue. Wenn beim Erstellen von gtest mit CMake BUILD_SHARED_LIBS deaktiviert ist und ich mein Programm mit diesen .lib-Dateien verknüpfe, werden die oben genannten Fehler angezeigt. Wenn jedoch BUILD_SHARED_LIBS aktiviert ist, erstelle ich eine Reihe von .lib- und .dll-Dateien. Beim Verknüpfen mit diesen .lib-Dateien wird das Programm kompiliert, beim Ausführen wird jedoch beanstandet, dass es gtest.dll nicht finden kann.

Dies liegt daran, dass Sie -DGTEST_LINKED_AS_SHARED_LIBRARY = 1 zu Compilerdefinitionen in Ihrem Projekt hinzufügen müssen, wenn Sie gtest als gemeinsam genutzte Bibliothek verwenden möchten.

Sie können auch die statischen Bibliotheken verwenden, vorausgesetzt, Sie haben sie mit der Option gtest_force_shared_crt kompiliert, um aufgetretene Fehler zu beseitigen.

Ich mag die Bibliothek, aber das Hinzufügen zum Projekt ist ein echtes Problem. Und Sie haben keine Chance, es richtig zu machen, es sei denn, Sie graben (und hacken) in die gtest-cmake-Dateien. Schande. Insbesondere gefällt mir die Idee, gtest als Quelle hinzuzufügen, nicht. :) :)

Das OP verwendet Windows, und eine viel einfachere Möglichkeit, GTest heute zu verwenden, ist vcpkg + cmake.

Installieren Sie vcpkg gemäß https://github.com/microsoft/vcpkg und stellen Sie sicher, dass Sie über vcpkgdie cmd-Zeile ausgeführt werden können. Beachten Sie den vcpkg-Installationsordner, z. C:\bin\programs\vcpkg.

Installieren Sie gtest mit vcpkg install gtest: Hiermit wird GTest heruntergeladen, kompiliert und installiert.

Verwenden Sie eine CmakeLists.txt wie folgt: Beachten Sie, dass wir Ziele verwenden können, anstatt Ordner einzuschließen .

cmake_minimum_required(VERSION 3.15)
project(sample CXX)
enable_testing()
find_package(GTest REQUIRED)
add_executable(test1 test.cpp source.cpp)
target_link_libraries(test1 GTest::GTest GTest::Main)
add_test(test-1 test1)

Führen Sie cmake aus mit: (Bearbeiten Sie ggf. den Ordner vcpkg und stellen Sie sicher, dass der Pfad zur Toolchain-Datei vcpkg.cmake korrekt ist.)

cmake -B build -DCMAKE_TOOLCHAIN_FILE=C:\bin\programs\vcpkg\scripts\buildsystems\vcpkg.cmake

und bauen cmake --build buildwie gewohnt. Beachten Sie, dass vcpkg auch die erforderliche gtest (d) .dll / gtest (d) _main.dll aus dem Installationsordner in die Debug / Release-Ordner kopiert.

Test mit cd build & ctest.

Ihre und VladLosevs Lösungen sind wahrscheinlich besser als meine. Wenn Sie jedoch eine Brute-Force-Lösung wünschen, versuchen Sie Folgendes:

SET(CMAKE_EXE_LINKER_FLAGS /NODEFAULTLIB:\"msvcprtd.lib;MSVCRTD.lib\")

FOREACH(flag_var
    CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
    CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
    if(${flag_var} MATCHES "/MD")
        string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
    endif(${flag_var} MATCHES "/MD")
ENDFOREACH(flag_var)

Die einfachste CMakeLists.txt, die ich aus den Antworten in diesem Thread und einigen Versuchen und Irrtümern herausgearbeitet habe, ist:

project(test CXX C)
cmake_minimum_required(VERSION 2.6.2)

#include folder contains current project's header filed
include_directories("include")

#test folder contains test files
set (PROJECT_SOURCE_DIR test) 
add_executable(hex2base64 ${PROJECT_SOURCE_DIR}/hex2base64.cpp)

# Link test executable against gtest nothing else required
target_link_libraries(hex2base64 gtest pthread)

Gtest sollte bereits auf Ihrem System installiert sein.

Nur als Aktualisierung des Kommentars von @ Patricia in der akzeptierten Antwort und des Kommentars von @ Fraser für die ursprüngliche Frage können Sie CMakes verwenden, wenn Sie Zugriff auf CMake 3.11+ haben FetchContent- Funktion aktualisieren .

Die FetchContent-Seite von CMake verwendet Googletest als Beispiel!

Ich habe eine kleine Änderung der akzeptierten Antwort bereitgestellt:

cmake_minimum_required(VERSION 3.11)
project(basic_test)

set(GTEST_VERSION 1.6.0 CACHE STRING "Google test version")

################################
# GTest
################################
FetchContent_Declare(googletest
GIT_REPOSITORY https://github.com/google/googletest.git
GIT_TAG release-${GTEST_VERSION})

FetchContent_GetProperties(googletest)
if(NOT googletest_POPULATED)
  FetchContent_Populate(googletest)
  add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR})
endif()

enable_testing()

################################
# Unit Tests
################################
# Add test cpp file
add_executable(runUnitTests testgtest.cpp)

# Include directories
target_include_directories(runUnitTests 
                      $<TARGET_PROPERTY:gtest,INTERFACE_SYSTEM_INCLUDE_DIRECTORIES>
                      $<TARGET_PROPERTY:gtest_main,INTERFACE_SYSTEM_INCLUDE_DIRECTORIES>)

# Link test executable against gtest & gtest_main
target_link_libraries(runUnitTests gtest
                                   gtest_main)

add_test(runUnitTests runUnitTests)

Sie können die INTERFACE_SYSTEM_INCLUDE_DIRECTORIESZieleigenschaft der Ziele gtest und gtest_main verwenden, wie sie im Skript goake test CMakeLists.txt festgelegt sind .

Ich beschloss, etwas Generisches ganz schnell zusammenzustellen, um eine andere Vorgehensweise als die zuvor veröffentlichten Antworten zu demonstrieren, in der Hoffnung, dass es jemandem helfen könnte. Folgendes funktionierte für mich auf meinem Mac. Zuerst habe ich Setup-Befehle für gtests ausgeführt. Ich habe gerade ein Skript verwendet, das ich gefunden habe, um alles einzurichten.

#!/usr/bin/env bash

# install gtests script on mac
# https://gist.github.com/butuzov/e7df782c31171f9563057871d0ae444a

#usage
# chmod +x ./gtest_installer.sh
# sudo ./gtest_installer.sh

# Current directory
__THIS_DIR=$(pwd)


# Downloads the 1.8.0 to disc
function dl {
    printf "\n  Downloading Google Test Archive\n\n"
    curl -LO https://github.com/google/googletest/archive/release-1.8.0.tar.gz
    tar xf release-1.8.0.tar.gz
}

# Unpack and Build
function build {
    printf "\n  Building GTest and Gmock\n\n"
    cd googletest-release-1.8.0
    mkdir build 
    cd $_
    cmake -Dgtest_build_samples=OFF -Dgtest_build_tests=OFF ../
    make
}

# Install header files and library
function install {
    printf "\n  Installing GTest and Gmock\n\n"

    USR_LOCAL_INC="/usr/local/include"
    GTEST_DIR="/usr/local/Cellar/gtest/"
    GMOCK_DIR="/usr/local/Cellar/gmock/"

    mkdir $GTEST_DIR

    cp googlemock/gtest/*.a $GTEST_DIR
    cp -r ../googletest/include/gtest/  $GTEST_DIR
    ln -snf $GTEST_DIR $USR_LOCAL_INC/gtest
    ln -snf $USR_LOCAL_INC/gtest/libgtest.a /usr/local/lib/libgtest.a
    ln -snf $USR_LOCAL_INC/gtest/libgtest_main.a /usr/local/lib/libgtest_main.a

    mkdir $GMOCK_DIR
    cp googlemock/*.a   $GMOCK_DIR
    cp -r ../googlemock/include/gmock/  $GMOCK_DIR
    ln -snf $GMOCK_DIR $USR_LOCAL_INC/gmock
    ln -snf $USR_LOCAL_INC/gmock/libgmock.a /usr/local/lib/libgmock.a
    ln -snf $USR_LOCAL_INC/gmock/libgmock_main.a /usr/local/lib/libgmock_main.a
}

# Final Clean up.
function cleanup {
    printf "\n  Running Cleanup\n\n"

    cd $__THIS_DIR
    rm -rf $(pwd)/googletest-release-1.8.0
    unlink $(pwd)/release-1.8.0.tar.gz
}

dl && build && install && cleanup 

Als nächstes habe ich eine einfache Ordnerstruktur erstellt und einige schnelle Klassen geschrieben

utils/
  cStringUtils.cpp
  cStringUtils.h
  CMakeLists.txt
utils/tests/
    gtestsMain.cpp
    cStringUtilsTest.cpp
    CMakeLists.txt

Ich habe eine CMakeLists.txt der obersten Ebene für den Ordner utils und eine CMakeLists.txt für den Testordner erstellt

cmake_minimum_required(VERSION 2.6)

project(${GTEST_PROJECT} C CXX)

set(CMAKE_C_STANDARD 98)
set(CMAKE_CXX_STANDARD 98)

#include .h and .cpp files in util folder
include_directories("${CMAKE_CURRENT_SOURCE_DIR}")

##########
# GTests
#########
add_subdirectory(tests)

Dies ist die CMakeLists.txt im Testordner

cmake_minimum_required(VERSION 2.6)

set(GTEST_PROJECT gtestProject)

enable_testing()

message("Gtest Cmake")

find_package(GTest REQUIRED)

# The utils, test, and gtests directories
include_directories("${CMAKE_CURRENT_SOURCE_DIR}")
include_directories("/usr/local/Cellar/gtest/include")
include_directories("/usr/local/Cellar/gtest/lib")

set(SOURCES
  gtestsMain.cpp
  ../cStringUtils.cpp
  cStringUtilsTest.cpp
)

set(HEADERS
  ../cStringUtils.h
)

add_executable(${GTEST_PROJECT} ${SOURCES})
target_link_libraries(${GTEST_PROJECT} PUBLIC
  gtest
  gtest_main
)

add_test(${GTEST_PROJECT} ${GTEST_PROJECT})

Dann müssen Sie nur noch ein Beispiel für gtest und gtest main schreiben

Probe gtest

#include "gtest/gtest.h"
#include "cStringUtils.h"

namespace utils
{

class cStringUtilsTest : public ::testing::Test {

 public:

  cStringUtilsTest() : m_function_param(10) {}
  ~cStringUtilsTest(){}

 protected:
  virtual void SetUp() 
  {
    // declare pointer 
    pFooObject = new StringUtilsC();    
  }

  virtual void TearDown() 
  {
    // Code here will be called immediately after each test
    // (right before the destructor).
    if (pFooObject != NULL)
    {
      delete pFooObject;
      pFooObject = NULL;
    }
  }


  StringUtilsC fooObject;              // declare object
  StringUtilsC *pFooObject;
  int m_function_param;                // this value is used to test constructor
};

TEST_F(cStringUtilsTest, testConstructors){
    EXPECT_TRUE(1);

  StringUtilsC fooObject2 = fooObject; // use copy constructor


  fooObject.fooFunction(m_function_param);
  pFooObject->fooFunction(m_function_param);
  fooObject2.fooFunction(m_function_param);
}

} // utils end

Beispiel gtest main

#include "gtest/gtest.h"
#include "cStringUtils.h"

int main(int argc, char **argv) {
  ::testing::InitGoogleTest(&argc, argv); 
  return RUN_ALL_TESTS();
}

Ich kann dann gtests mit den folgenden Befehlen aus dem Ordner utils kompilieren und ausführen

cmake .
make 
./tests/gtestProject