Google Test 1.6.0
http://code.google.com/p/googletest/
New BSD License
1.6.0
10.07.2012
Bei Google Test handelt es sich um ein plattformunabhängiges C++ Testing Framework. Mit dem Framework lassen sich automatisierte
Unit-Tests erstellen. Dabei lassen sich verschiedene Tests in unterschiedlichen Testsuiten zusammenfassen. Insgesamt lassen sich drei
verschiedene SetUp-Methoden verwenden, jeweils für das Programm, die Testsuiten und die einzelnen Testfälle. Das Ergebnis wird
wahlweise direkt in der Konsole oder in einer XML-Datei ausgegeben. Weiterhin lassen sich Fehlermeldungen erweitern und eigene erstellen.
Obwohl das Google Test Framework sehr umfangreich ist, ist es dennoch sehr einsteigerfreundlich. Dafür sorgt unter anderem die
Dokumentation, welche in einen Einsteiger- und Fortgeschrittenenteil gegliedert ist. In dem Einsteigerteil finden Anfänger alle
wichtigen Informationen, um erste Tests zu schreiben. Der Fortgeschrittenenteil beschreibt, wie das Arbeiten mit dem Framework vereinfacht
werden kann. Die Installation ist ziemlich aufwendig, da der Code selbst kompiliert werden muss. Später müssen die Library und
die Header-Dateien zu jedem Projekt hinzugefügt werden. Die Dokumentation und das Framework werden stetig weiterentwickelt.
Google Test wird von C++ Entwicklern eingesetzt. Mit dem Framework werden White-Box-Tests erstellt.
Standalone in der Konsole, Eclipse Plugin oder
eigene GUI
Allgemein
Um Google Test verwenden zu können, muss das Framework als statische Bibliothek kompiliert werden. Dazu muss die src/gtest-all.cc,
mit dem Google Test Stammverzeichnis und dem include Verzeichnis als Header-Suchpfad, kompiliert werden.
Später muss bei jedem zu testenden Projekt, das Google Test include-Verzeichnis als Header-Suchpfad angegeben werden.
Zusätzlich muss die statische Library im Projekt gelinkt werden.
Eclipse
Google Test
01) File -> New -> C++ Project
02.1) Projektname angeben
02.2) Static Library -> Empty Project
03) Debug abwählen
04) src/gtest-all.cc in das Projekt kopieren
05.1) Project -> Properties -> C/C++ Build -> Settings
05.2) Tool Settings -> GCC C++ Compiler -> Includes
05.2.1) Google Test Stammverzeichnis als Include Pfad hinzufügen
05.2.2) Google Test include Ordner als Include Pfad hinzufügen
05.3) Build Artifact
05.3.1) Artifact name: gtest
05.3.2) Artifact extension: lib
05.3.3) Output prefix: leer
06) Project -> Build all
Tests Runner Plugin
01) Help -> Install New Software
02) Work with: https://raw.github.com/xgsa/cdt-tests-
runner/tests_runner_demo/testsrunner/org.eclipse.cdt.testsrunner-updatesite/site.xml
03) Installieren
Auf der Projektseite befindet sich eine Dokumentation. Die
Dokumentation wurde mit viel Mühe erstellt. Es gibt zu fast jedem Punkt ein kleines erklärendes Beispiel und hilfreiche Randnotizen.
Die Dokumentation ist in einen Einsteigerteil und einem
Fortgeschrittenenteil gegliedert. Daneben gibt es noch eine
FAQ und zehn ausführliche und kommentierte
Beispiele.
Bei der Projektseite handelt es sich um eine Google Code Seite. Neben der sehr ausführlichen englischen Dokumentation finden Nutzer
einen "Issues"-Bereich, in dem die Nutzer Probleme schildern können. Die Dokumentation wird stetig weiter bearbeitet,
die letzte Änderung wurde im Untersuchungsmonat (Juli 2012) vorgenommen.
Es gibt den "Issues"-Bereich und eine
Gruppe bei Google Groups.
Um etwas in der Gruppe schreiben zu können, muss der Gruppe beigetreten werden. Lesen ist ohne Anmeldung möglich.
Im "Issue"-Bereich können Probleme mit einem Google-Account geschildert werden. Das Lesen der Einträge ist
auch hier ohne Anmeldung möglich. Zusätzlichen finden sich auf der Projektseite E-Mail Adressen der Projektverantwortlichen,
welche aber auch in der Gruppe aktiv sind.
Nachdem alle Vorbereitungen abgeschlossen sind, lässt sich das Framework leicht bedienen. Die Library und der in include-Pfad muss
im Projekt angegeben werden. Für das Plugin muss die auszuführende Datei (vorher einmal das Projekt kompilieren) und das
Test-Framework gewählt werden. Danach muss das Google Test-Framework in der main-Funktion aufgerufen und die
verschiedenen Tests geschrieben werden. Optional können für die verschiedenen Testfälle SetUp und TearDown Methoden
geschrieben werden. Die Tests lassen sich nun automatisiert durchlaufen.
Sofern die Tests erstellt wurden, ist kein weiterer Eingriff nötig. Der komplette Testlauf läuft selbstständig ab.
Vorbereitung
Bevor die Tests durchgeführt werden können, muss das Projekt vorbereitet werden. Dazu sind einige Einstellungen in
Eclipse nötig. Der Google Test include-Ordner muss angegeben, die Library muss gelinkt und das Plugin
muss eingerichtet werden.
01.1) Project -> Properties -> C/C++ Build -> Settings
01.2) Tool Settings -> GCC C++ Compiler -> Includes
01.2.1) Google Test include-Ordner angeben
01.3) Tool Settings -> MinGW C++ Linker -> Libraries
01.3.1) Dateiname der Library angeben
01.3.2) Pfad zur Library angeben
2) Plugin einrichten
2.1) Run -> Run Configurations
2.1.1) Neue C/C++ Unit Konfiguration anlegen
2.2) Main
2.2.1) C/C++ Application angeben (vorher kompilieren)
2.2.1) Projekt angeben
2.3) C/C++ Testing
2.3.1) Google Tests Runner auswählen
3) main-Funktion anpassen
#include "gtest/gtest.h"
int main(int argc, char **argv)
{
std::cout << "******* TESTs *******" << std::endl;
::testing::InitGoogleTest(&argc, argv);
RUN_ALL_TESTS();
std::cout << std::endl;
return 0;
}
Tests
Dateien:
main.cpp
Fakultaet.cpp (Header)
WahrFalsch.cpp (Header)
Unittests.cpp
Gesamt (Zip-Archiv)
Für einfache Tests, ohne SetUp und TearDown Methoden, muss nur das TEST()-Makro aufgerufen werden.
TEST(WahrFalschTest, BeideWahrBeideWahr) {
WahrFalsch obj;
EXPECT_TRUE(obj.BeideWahr(true,true))<<"Einer Falsch";
}
Bei den Parametern des TEST()-Makros handelt es sich bei dem ersten um den Namen der Testklasse und der zweite Parameter ist der
Name des Tests. In dem Makro können die Annahmen getestet werden. EXPECT_TRUE(Bedingung) erwartet, dass die Methode BeideWahr()
true zurück liefert. Das logische Gegenstück zu EXPECT_TRUE() ist EXPECT_FALSE() und erwartet false als Rückgabewert. Der
Ausgabeoperator ist im Testframework überladen. So lassen sich zusätzliche Informationen im Fehlerfall ausgeben. Die Ausgabe
findet nur in der Konsole statt, nicht im Test Runner Plugin.
Werden SetUp und TearDown Methoden benötigt, so muss eine neue Klasse geschrieben werden, welche die Klasse "Test"
vom Google Test Framework erbt. Die SetUp-Methode wird vor jedem Test aufgerufen und die TearDown-Methode danach. Dadurch wird
sichergestellt, dass die Tests unter gleichbleibenden Bedingungen ausgeführt werden.
class FakultaetTest : public testing::Test {
protected:
virtual void SetUp() {
}
virtual void TearDown() {
}
Fakultaet obj;
};
In diesem Fall erbt die neu erstellte Klasse FakultaetTest von der der Klasse Test. Die Methoden SetUp und TearDown werden dabei
von der neuen Klasse überladen. Der Klassenname ist automatische der Name des Testfalls.
TEST_F(FakultaetTest, Iterativ) {
EXPECT_ANY_THROW(obj.iterativ(-3))
EXPECT_NO_THROW(obj.iterativ(3));
EXPECT_EQ(6,obj.iterativ(3));
}
Zu beachten ist, dass nun nicht mehr das TEST()-Makro verwendet wird, sondern das TEST_F()-Makro. Der Zusatz _F steht für fixture.
Weiterhin ist zu beachten, dass der erste Parameter der Name der zuvor erstellten Klasse ist. Die Tests können mit diesem Makro mit
den selben Annahmen erstellt werden, wie in dem TEST()-Makro.
EXPECT_ANY_THROW(Methode); - ist true, sofern eine Expcetion geworfen wurde
EXPECT_NO_THROW(Methode); - ist true, sofern keine Exception geworfen wurde
EXPECT_EQ(exp, act); - liefert true, wenn beide Werte übereinstimmen
Mit dem Google Test Framework ist es ebenfalls möglich, automatisch den selben Testfall mit unterschiedlichen Parametern
durchzuführen. Für diese Anwendung gibt es das TEST_P-Makro. Der Zusatz _P steht in diesem Fall für params.
class FakultaetParamsTest : public ::testing::TestWithParam {
protected:
virtual void SetUp() {
}
virtual void TearDown() {
}
};
Die neu erstelle Klasse FakultaetParamsTest erbt von dem TestWithParam Template. Die Klasse lässt sich genauso verwenden,
wie eine "fixture"-Klasse.
INSTANTIATE_TEST_CASE_P(TestSequence, FakultaetParamsTest, testing::Range(1,5));
Der erste Parameter ist ein Präfix, welcher an den Namen des Testfalls angehängt wird. Dadurch lassen sich die unterschiedlichen
Instanzen unterscheiden. Bei dem zweiten Parameter handelt es sich um den Namen der Klasse / des Testfalls. Als letztes werden die
Parameter übergeben. In diesem Fall handelt es sich um den Zahlenbereich zwischen 1 und 5.
Mit ::testing::Values("Val1","Val2",...) ließen sich z.B. bestimmte Werte übergeben.
TEST_P(FakultaetParamsTest, TestMitParametern) {
EXPECT_EQ(obj.iterativ(GetParam()),obj.rekursiv(GetParam()));
}
Die Tests werden fast genauso geschrieben wie oben. Nur muss nun das TEST_P-Makro aufgerufen werden. Mittels GetParam()
ist es möglich, auf den aktuellen Wert zuzugreifen.
Ist schon eine Klasse für den Testfall vorhanden, lässt sich der Parameter Aufruf hinzufügen.
class FakultaetTest : public testing::Test {
};
class FakultaetParamsTest: public FakultaetTest , public ::testing::WithParamInterface {
};
Der Test kann nun über die in den Vorbereitung eingestellten C/C++ Unit Konfiguration aufgerufen werden.
Dazu Run -> Run Configuration -> Konfiguration auswählen -> Run klicken. Danach lässt sich die Konfiguration
auch über die Historie aufrufen.
Ausgabe des Test Runner Plugins.
Ausgabe in der Konsole
Neben den EXPECT_-Annahmen sind alle Annahmen weiterhin als ASSERT_-Annahmen vorhanden. EXPECT_-Annahmen sind nicht-schwerwiegende Annahmen,
die Prüfung des Testfalls wird dabei ungehindert fortgeführt. ASSERT_-Annahmen sind hingegen schwerwiegende Annahmen, der Testfall
wird direkt abgebrochen.
Eine detaillierte Beschreibung befindet sich in der
Google Test Dokumentation.
Keine gesonderte Literatur vorhanden.