So beginnen Sie mit GTest und CMake zu arbeiten

125

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?

Chris
quelle
4
Sie können vermeiden, GTest-Quellen in Ihre eigenen aufzunehmen, indem Sie ExternalProject_Addanstatt verwenden add_subdirectory. Siehe diese Antwort für Details.
Fraser
Warum haben wir im obigen Lösungsbeispiel Zugriff auf $ {gtest_SOURCE_DIR}? Wie / wo wird diese Variable deklariert?
Dmonopol
Oh, es ist in gtest-1.6.0 / CMakeLists.txt deklariert: "project (gtest CXX C)", wodurch die Variablen gtest_SOURCE_DIR und gtest_BINARY_DIR verfügbar werden.
Dmonopol
1
Was macht enable_testing()das
updogliu
1
@updogliu: Aktiviert ctest und das Ziel 'test' (oder 'RUN_TESTS'). Es wird zusammen mit dem Befehl add_test () cmake abgespielt.
Ela782

Antworten:

76

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 )
Chris
quelle
3
Ich bin nicht sicher, was der add_test () macht, aber es scheint nicht dazu zu führen, dass die Test-Binärdatei ausgeführt wird ... Vermisse ich etwas?
weberc2
4
Nicht um ein totes Pferd zu schlagen, aber ich dachte, das wäre noch einmal erwähnenswert. Frasers Kommentar oben macht einen sehr wichtigen Punkt: "Sie können vermeiden, GTest-Quellen in Ihre eigenen aufzunehmen, indem Sie ExternalProject_Add anstelle von add_subdirectory verwenden." Siehe Frasers Antwort und Kommentare für Details hier: stackoverflow.com/a/9695234/1735836
Patricia
1
In meinem Fall musste ich auch pthreaddie verknüpften Bibliotheken ergänzen und die vorletzte Zeile intarget_link_libraries(runUnitTests gtest gtest_main pthread)
panmari
3
@ weberc2 Sie müssen ausführen make test, um die Tests auszuführen, oder ctestvom Build-Verzeichnis aus ausführen . Führen Sie aus ctest -V, um die Google-Testausgabe sowie die ctestAusgabe anzuzeigen.
Patrick
38

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)
user1427799
quelle
7
Ich weiß nicht, warum du dafür herabgestimmt wurdest. Ihre Lösung verhindert, dass jemand Google Test zur Versionskontrolle einchecken muss. Ein großes Lob für Ihre Lösung.
Sal
4
Die von Ihnen verwendete URL ist jetzt fehlerhaft. Eine aktuelle URL isthttps://github.com/google/googletest/archive/release-1.8.0.zip
oscfri
Gute Antwort. Sollte Nummer 1 sein.
Mr00Anderson
1
Antwort erstellen! auch können wir GIT_REPOSITORY https://github.com/google/googletest.git GIT_TAG release-1.8.1anstelle von URL
TingQian LI
Die URL zur neuesten Version von gtest lautet:https://github.com/google/googletest/archive/release-1.10.0.zip
vahancho
16

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:

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

Craig Scott
quelle
2
IMO, dies ist vielleicht der sauberste Weg, um den Google-Test mit einem CMake-Projekt zu implementieren. Ich wünschte, die Moderatoren würden dem Inhalt und der Qualität der Antworten mehr Aufmerksamkeit schenken.
NameRakes
Das verknüpfte generalisierte Modul DownloadProject.cmake ist großartig. Es scheint die Grundlage für cmake zu sein, ein Paketverwaltungssystem zu haben, bei dem ich lediglich eine Liste mit Links zu CMake-kompatiblen Github-URLs benötige.
Josh Peak
13

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.

VladLosev
quelle
1
Vielen Dank, ich wusste nicht, dass Sie innerhalb derselben CMakeLists völlig separate Projekte erstellen können. Ich kann jetzt mit Sicherheit sagen, dass EXPECT_EQ (1.0 == 1.0) erfolgreich ist und EXPECT_EQ (0.0 == 1.0) fehlschlägt. Jetzt Zeit für weitere echte Tests ...
Chris
2

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. :) :)

Slava
quelle
1

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.

Daniele
quelle
0

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)
Torleif
quelle
0

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.

AlexBriskin
quelle
Es ist wirklich keine gute Praxis, eine solche Bibliothek in CMake hinzuzufügen. Eines der Hauptziele von cmake ist es, niemals Annahmen wie "Diese Bibliotheken sollten bereits installiert sein ..." treffen zu müssen. CMake überprüft, ob die Bibliothek hier ist, und wenn nicht, wird ein Fehler ausgegeben.
Adrien BARRAL
0

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 .

Mr. Splat
quelle
In CMake> = v3.14 können Sie auf das Explizite verzichten target_include_directoriesund FetchContent_MakeAvailable(googletest)stattdessen verwenden. Dadurch wird der Inhalt sowohl ausgefüllt als auch zum Haupt-Build hinzugefügt. CMake FetchContent - weitere Informationen
67hz
0

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
Liebe zeigen
quelle