Migrate boost unit test to google test with cmake (ctest)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7acd9b1..dbce3e3 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -178,7 +178,10 @@ ENDFOREACH()
 
 
 # <test>
-find_package(Boost COMPONENTS system filesystem REQUIRED)
+enable_testing()
+find_package(GTest REQUIRED)
+include_directories(${GTEST_INCLUDE_DIRS})
+
 SUBDIRLIST(MODULES ${CMAKE_CURRENT_SOURCE_DIR}/test)
 FOREACH(module ${MODULES})
 
@@ -188,21 +191,18 @@ FOREACH(module ${MODULES})
   file(GLOB_RECURSE SRCS ${CMAKE_CURRENT_SOURCE_DIR}/test/${module}/*.cpp)
 
   # Executable
-  set(target "${module}")
-  find_package(Boost COMPONENTS system filesystem unit_test_framework REQUIRED)
+  set(target "test_${module}")
   add_executable(${target} "${SRCS}")
-  set_target_properties(${target} PROPERTIES LINKER_LANGUAGE CXX)
-
-
-  set(libraries_file "${CMAKE_CURRENT_SOURCE_DIR}/example/${module}/${subdir}/libraries.txt")
+  target_link_libraries(${target} ${GTEST_BOTH_LIBRARIES} pthread)
+  set(libraries_file "${CMAKE_CURRENT_SOURCE_DIR}/test/${module}/libraries.txt")
 
   if(EXISTS "${libraries_file}")
     file (STRINGS "${libraries_file}" LIBS)
     #message(STATUS "Libraries: ${LIBS}")
-    target_link_libraries(${target} ${Boost_FILESYSTEM_LIBRARY} ${Boost_SYSTEM_LIBRARY} ${LIBS})
+    target_link_libraries(${target} ${GTEST_BOTH_LIBRARIES} pthread ${LIBS})
   endif()
 
-  add_test(tester tester)
+  add_test(${target} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${target})
 
 ENDFOREACH()
 

diff --git a/test/config/libraries.txt b/test/config/libraries.txt
new file mode 100644 (file)
index 0000000..034855a
--- /dev/null
+++ b/test/config/libraries.txt
@@ -0,0 +1 @@
+config_static

diff --git a/test/config/main.cpp b/test/config/main.cpp
index ab4fa7b..2737c39 100644 (file)
--- a/test/config/main.cpp
+++ b/test/config/main.cpp
@@ -6,11 +6,6 @@
 // See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
 
 
-#define BOOST_TEST_MODULE ANNA_CONFIG_TEST
-
-#include <anna/test/clang_specific.hpp>
-#include <boost/test/included/unit_test.hpp>
-
 #include <iostream>
 
 #include <limits.h>
@@ -18,32 +13,42 @@
 #include <anna/config/Release.hpp>
 #include <anna/core/util/defines.hpp>
 
+#include <gtest/gtest.h>
+
+
 using namespace std;
 using namespace anna;
 
-BOOST_AUTO_TEST_CASE(release) {
+TEST(config, release) {
   string version = config::Release::getVersion();
   cout << version << endl;
-  BOOST_REQUIRE(version.empty() == false);
+  EXPECT_TRUE(version.empty() == false);
   int debug = version.find("/D");
   int release = version.find("/O");
 #ifdef _DEBUG
-  BOOST_REQUIRE(debug != string::npos);
-  BOOST_REQUIRE(release == string::npos);
+  EXPECT_TRUE(debug != string::npos);
+  EXPECT_TRUE(release == string::npos);
 #else
-  BOOST_REQUIRE(debug == string::npos);
-  BOOST_REQUIRE(
+  EXPECT_TRUE(debug == string::npos);
+  EXPECT_TRUE(
     release != string::npos);
 #endif
 }
 
-BOOST_AUTO_TEST_CASE(numbers) {
+TEST(config, numbers) {
   S64 ii64;
   ii64 = LLONG_MAX;
-  BOOST_REQUIRE_EQUAL(ii64, LLONG_MAX);
+  EXPECT_EQ(ii64, LLONG_MAX);
   ii64 = LLONG_MIN;
-  BOOST_REQUIRE_EQUAL(ii64, LLONG_MIN);
+  EXPECT_EQ(ii64, LLONG_MIN);
   U64 u64;
   u64 = ULLONG_MAX;
-  BOOST_REQUIRE_EQUAL(u64, ULLONG_MAX);
+  EXPECT_EQ(u64, ULLONG_MAX);
 }
+
+int main(int argc, char **argv)
+{
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
+

diff --git a/test/core/libraries.txt b/test/core/libraries.txt
new file mode 100644 (file)
index 0000000..570d1d0
--- /dev/null
+++ b/test/core/libraries.txt
@@ -0,0 +1 @@
+core_static

diff --git a/test/core/main.cpp b/test/core/main.cpp
index c32916f..bdff099 100644 (file)
--- a/test/core/main.cpp
+++ b/test/core/main.cpp
@@ -5,12 +5,6 @@
 // See project site at http://redmine.teslayout.com/projects/anna-suite                           //
 // See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
 
-
-#define BOOST_TEST_MODULE ANNA_CORE_TEST
-
-#include <anna/test/clang_specific.hpp>
-#include <boost/test/included/unit_test.hpp>
-
 #include <iostream>
 #include <string>
 
@@ -21,63 +15,63 @@
 #include <anna/core/util/Environment.hpp>
 #include <anna/core/functions.hpp>
 
+#include <gtest/gtest.h>
+
+
 using namespace std;
 using namespace anna;
 
-// see http://www.boost.org/doc/libs/1_44_0/libs/test/doc/html/utf/testing-tools.html
-//     http://www.boost.org/doc/libs/1_44_0/libs/test/doc/html/utf/testing-tools/reference.html
 
-BOOST_AUTO_TEST_CASE(tokenizer) {
+TEST(core, tokenizer) {
   anna::Tokenizer lst;
   lst.apply("In three words", " ");
-  //BOOST_REQUIRE(lst.size() == 3);
-  BOOST_REQUIRE_EQUAL(lst.size(), 3);
+  EXPECT_EQ(lst.size(), 3);
   anna::Tokenizer::const_iterator tok_iter(lst.begin());
-  BOOST_REQUIRE_EQUAL(anna::Tokenizer::data(tok_iter++), "In");
-  BOOST_REQUIRE_EQUAL(anna::Tokenizer::data(tok_iter++), "three");
-  BOOST_REQUIRE_EQUAL(anna::Tokenizer::data(tok_iter++), "words");
-  BOOST_REQUIRE_EQUAL(tok_iter, lst.end());
-  BOOST_CHECK_THROW(lst.at(10), anna::RuntimeException);
+  ASSERT_STREQ(anna::Tokenizer::data(tok_iter++), "In");
+  ASSERT_STREQ(anna::Tokenizer::data(tok_iter++), "three");
+  ASSERT_STREQ(anna::Tokenizer::data(tok_iter++), "words");
+  EXPECT_EQ(tok_iter, lst.end());
+  ASSERT_THROW(lst.at(10), anna::RuntimeException);
   lst.apply("In three words", ",");
-  BOOST_REQUIRE_EQUAL(lst.size(), 1);
+  EXPECT_EQ(lst.size(), 1);
   lst.apply("", ",");
-  BOOST_REQUIRE_EQUAL(lst.size(), 0);
-  BOOST_CHECK_THROW(lst.last(), anna::RuntimeException);
+  EXPECT_EQ(lst.size(), 0);
+  ASSERT_THROW(lst.last(), anna::RuntimeException);
 //  std::string str = "";
 //  for (int k = 0; k < 100; k++)
 //    str += "x ";
-//  BOOST_CHECK_THROW(lst.apply(str, " "), anna::RuntimeException);
+//  ASSERT_THROW(lst.apply(str, " "), anna::RuntimeException);
 }
 
-BOOST_AUTO_TEST_CASE(functions_asString) {
+TEST(core, functions_asString) {
   std::string msg = anna::functions::asString("One %s has %d legs. Two %s have %d legs", "horse", 4, "horses", 8);
-  BOOST_REQUIRE_EQUAL(msg, "One horse has 4 legs. Two horses have 8 legs");
+  EXPECT_EQ(msg, "One horse has 4 legs. Two horses have 8 legs");
   char cad_aux[128];
   sprintf(cad_aux, "%d", 123);
-  BOOST_REQUIRE_EQUAL(anna::functions::asString(123), cad_aux);
+  EXPECT_EQ(anna::functions::asString(123), cad_aux);
   unsigned long ul = 43200111UL;
   sprintf(cad_aux, "%lu", ul);
-  BOOST_REQUIRE_EQUAL(anna::functions::asString(ul), cad_aux);
+  EXPECT_EQ(anna::functions::asString(ul), cad_aux);
   unsigned long long ull = 4321000111ULL;
   sprintf(cad_aux, "%llu", ull);
-  BOOST_REQUIRE_EQUAL(anna::functions::asString(ull), cad_aux);
+  EXPECT_EQ(anna::functions::asString(ull), cad_aux);
   U64 u64 = ull;
-  BOOST_REQUIRE_EQUAL(anna::functions::asString(u64), cad_aux);
+  EXPECT_EQ(anna::functions::asString(u64), cad_aux);
   unsigned int ui = 1234567890U;
   sprintf(cad_aux, "%u", ui);
-  BOOST_REQUIRE_EQUAL(anna::functions::asString(ui), cad_aux);
+  EXPECT_EQ(anna::functions::asString(ui), cad_aux);
   float f = 123.34;
   double d = 3.1415;
   sprintf(cad_aux, "%4.2f", f);
-  BOOST_REQUIRE_EQUAL(anna::functions::asString(f, "%4.2f"), cad_aux);
+  EXPECT_EQ(anna::functions::asString(f, "%4.2f"), cad_aux);
   sprintf(cad_aux, "%4.2f", d);
-  BOOST_REQUIRE_EQUAL(anna::functions::asString(d, "%4.2f"), cad_aux);
+  EXPECT_EQ(anna::functions::asString(d, "%4.2f"), cad_aux);
 }
 
-BOOST_AUTO_TEST_CASE(configuration) {
+TEST(core, configuration) {
   anna::Configuration conf;
-  BOOST_CHECK_THROW(conf.load("missing_file.cnf"), anna::RuntimeException);
-  BOOST_CHECK_NO_THROW(conf.load("test/core/example.cnf"));
+  ASSERT_THROW(conf.load("missing_file.cnf"), anna::RuntimeException);
+  ASSERT_NO_THROW(conf.load("test/core/example.cnf"));
   //[ property ]
   //thing = tshirt
   //size = 1
@@ -85,32 +79,39 @@ BOOST_AUTO_TEST_CASE(configuration) {
   //[ owner ]
   //name = edu
   //address = madrid
-  BOOST_CHECK_THROW(conf.getValue("property", "WRONG_VAR"), anna::RuntimeException);
-  BOOST_CHECK_THROW(conf.getValue("WRONG_SECTION", "thing"), anna::RuntimeException);
+  ASSERT_THROW(conf.getValue("property", "WRONG_VAR"), anna::RuntimeException);
+  ASSERT_THROW(conf.getValue("WRONG_SECTION", "thing"), anna::RuntimeException);
   std::string value;
-  BOOST_REQUIRE_EQUAL(value = conf.getValue("property", "thing"), "tshirt");
-  BOOST_REQUIRE_EQUAL(conf.getIntegerValue("property", "size"), 1);
-  BOOST_REQUIRE_EQUAL(std::string(conf.getValue("property", "color")), "blue");
-  BOOST_REQUIRE_EQUAL(std::string(conf.getValue("owner", "name")), "edu");
-  BOOST_REQUIRE_EQUAL(std::string(conf.getValue("owner", "address")), "madrid");
+  EXPECT_EQ(value = conf.getValue("property", "thing"), "tshirt");
+  EXPECT_EQ(conf.getIntegerValue("property", "size"), 1);
+  EXPECT_EQ(std::string(conf.getValue("property", "color")), "blue");
+  EXPECT_EQ(std::string(conf.getValue("owner", "name")), "edu");
+  EXPECT_EQ(std::string(conf.getValue("owner", "address")), "madrid");
   conf.setDefaultValue("owner", "phone", "555 55 55");
-  BOOST_REQUIRE_EQUAL(std::string(conf.getValue("owner", "phone")), "555 55 55");
-  BOOST_REQUIRE(!conf.getValue("owner", "phone", true) /* query value is NULL: 'true = strict' even with default value assigned */);
-  BOOST_REQUIRE(!conf.exists("owner", "phone"));
-  BOOST_REQUIRE(conf.exists("owner", "name"));
+  EXPECT_EQ(std::string(conf.getValue("owner", "phone")), "555 55 55");
+  EXPECT_TRUE(!conf.getValue("owner", "phone", true)); // query value is NULL: 'true = strict' even with default value assigned
+  EXPECT_TRUE(!conf.exists("owner", "phone"));
+  EXPECT_TRUE(conf.exists("owner", "name"));
 }
 
-BOOST_AUTO_TEST_CASE(environment) {
+TEST(core, environment) {
   anna::Environment &env = anna::Environment::instantiate();
   env.initialize();
-  BOOST_CHECK_THROW(env.getValue("WRONG_ENV_VAR", true), anna::RuntimeException); // true => exception if missing
-  BOOST_CHECK_THROW(env.getValue(NULL), anna::RuntimeException);
+  ASSERT_THROW(env.getValue("WRONG_ENV_VAR", true), anna::RuntimeException); // true => exception if missing
+  ASSERT_THROW(env.getValue(NULL), anna::RuntimeException);
   env.setVariable("TEST_VAR", "my test var value");
-  BOOST_REQUIRE_EQUAL(env.getValue("TEST_VAR"), std::string("my test var value"));
-  env.setVariable("TEST_VAR", "my new test var value", false /* no overwritting */);
-  BOOST_REQUIRE_EQUAL(env.getValue("TEST_VAR"), std::string("my test var value"));
+  EXPECT_EQ(env.getValue("TEST_VAR"), std::string("my test var value"));
+  env.setVariable("TEST_VAR", "my new test var value", false);  // false: no overwritting
+  EXPECT_EQ(env.getValue("TEST_VAR"), std::string("my test var value"));
   env.unsetVariable("TEST_VAR");
-  BOOST_REQUIRE_EQUAL(env.getValue("TEST_VAR"), std::string(""));
-  BOOST_REQUIRE_EQUAL(env.getValue("MISSING_ENV_VAR"), std::string(""));
+  EXPECT_EQ(env.getValue("TEST_VAR"), std::string(""));
+  EXPECT_EQ(env.getValue("MISSING_ENV_VAR"), std::string(""));
+}
+
+
+int main(int argc, char **argv)
+{
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
 }
 

diff --git a/test/time/libraries.txt b/test/time/libraries.txt
new file mode 100644 (file)
index 0000000..33cfe20
--- /dev/null
+++ b/test/time/libraries.txt
@@ -0,0 +1,3 @@
+time_static
+xml_static
+core_static

diff --git a/test/time/main.cpp b/test/time/main.cpp
index b5d0d28..8ad07fc 100644 (file)
--- a/test/time/main.cpp
+++ b/test/time/main.cpp
@@ -6,24 +6,18 @@
 // See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
 
 
-#define BOOST_TEST_MODULE ANNA_TIME_TEST
-
-#include <anna/test/clang_specific.hpp>
-#include <boost/test/included/unit_test.hpp>
-
-//#include <iostream>
 #include <string>
-
 #include <anna/time/Date.hpp>
 #include <anna/time/functions.hpp>
 
+#include <gtest/gtest.h>
+
 using namespace std;
 using namespace anna;
 
-// see http://www.boost.org/doc/libs/1_44_0/libs/test/doc/html/utf/testing-tools.html
-//     http://www.boost.org/doc/libs/1_44_0/libs/test/doc/html/utf/testing-tools/reference.html
 
-BOOST_AUTO_TEST_CASE(date) {
+TEST(date, Conversions)
+{
   anna::time::functions::initialize();
   anna::time::Date current, current2;
   current.setNow();
@@ -33,26 +27,26 @@ BOOST_AUTO_TEST_CASE(date) {
   std::string ntpStr = current2.asString();
   current2.storeUnix(unixtime);
   std::string unixStr = current2.asString();
-  BOOST_REQUIRE_EQUAL(ntpStr, unixStr);
+  EXPECT_EQ(ntpStr, unixStr);
 
   anna::time::Date myBirth("CET"); // 19 December 1974, 10:00 (GMT+1 = UTC + 1 = CET)
   myBirth.store("19741219101500"); // yyyymmddHHmmss
   anna::time::Date same_moment_canary_island("GMT");
   same_moment_canary_island.store(myBirth.getUnixTimestamp());
   myBirth.setTz("GMT");
-  BOOST_REQUIRE_EQUAL(same_moment_canary_island.yyyymmddHHmmss(), myBirth.yyyymmddHHmmss());
+  EXPECT_EQ(same_moment_canary_island.yyyymmddHHmmss(), myBirth.yyyymmddHHmmss());
 
   anna::time::Date birthday("EET");
   birthday.store(same_moment_canary_island.getTm(), "GMT");  // TZ origin = "GMT"
-  BOOST_REQUIRE_EQUAL(birthday.getUnixTimestamp(), myBirth.getUnixTimestamp());
+  EXPECT_EQ(birthday.getUnixTimestamp(), myBirth.getUnixTimestamp());
 
   myBirth.setTz();
   birthday.setTz();
-  BOOST_REQUIRE_EQUAL(myBirth.asString(), birthday.asString());
-  BOOST_REQUIRE_EQUAL(myBirth.yyyymmddHHmmss(), birthday.yyyymmddHHmmss());
+  EXPECT_EQ(myBirth.asString(), birthday.asString());
+  EXPECT_EQ(myBirth.yyyymmddHHmmss(), birthday.yyyymmddHHmmss());
 
   myBirth.setTz("GMT");
-  BOOST_REQUIRE_EQUAL(myBirth.yyyymmddHHmmss(), "19741219091500");
+  EXPECT_EQ(myBirth.yyyymmddHHmmss(), "19741219091500");
 
   // Adding 18 years to 'myBirth':
   same_moment_canary_island.setTz("CET");
@@ -60,7 +54,15 @@ BOOST_AUTO_TEST_CASE(date) {
   struct tm Tm = myBirth.getTm();
   Tm.tm_year += 18;
   eighteen.store(Tm, "GMT");
-  BOOST_REQUIRE(eighteen >= same_moment_canary_island);
-  BOOST_REQUIRE_EQUAL(eighteen.yyyymmddHHmmss(), "19921219101500");
+  EXPECT_TRUE(eighteen >= same_moment_canary_island);
+  EXPECT_EQ(eighteen.yyyymmddHHmmss(), "19921219101500");
+}
+
+
+
+int main(int argc, char **argv)
+{
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
 }