Convert configargs unit tests to Google Test

2 files changed, 78 insertions, 115 deletions

diff --git a/tests/unit/CMakeLists.txt b/tests/unit/CMakeLists.txt
index fb99e820..f82e9f2e 100644
--- a/tests/unit/CMakeLists.txt
+++ b/tests/unit/CMakeLists.txt
@@ -9,7 +9,8 @@ include_directories(${CMAKE_SOURCE_DIR}/common)
 include_directories(${CMAKE_SOURCE_DIR}/vncviewer)
 
 add_executable(configargs configargs.cxx)
-target_link_libraries(configargs rfb)
+target_link_libraries(configargs rfb GTest::gtest_main)
+gtest_discover_tests(configargs)
 
 add_executable(conv conv.cxx)
 target_link_libraries(conv rfb)
diff --git a/tests/unit/configargs.cxx b/tests/unit/configargs.cxx
index 2adad829..2d3406f3 100644
--- a/tests/unit/configargs.cxx
+++ b/tests/unit/configargs.cxx
@@ -20,8 +20,7 @@
 #include <config.h>
 #endif
 
-#include <stdio.h>
-#include <string.h>
+#include <gtest/gtest.h>
 
 #include <core/Configuration.h>
 
@@ -29,23 +28,11 @@ static core::BoolParameter boolparam("boolparam", "", false);
 static core::IntParameter intparam("intparam", "", 0);
 static core::StringParameter strparam("strparam", "", "");
 
-#define ASSERT_EQ_I(expr, val) if ((expr) != (val)) { \
-  printf("FAILED on line %d (%s equals %d, expected %d)\n", __LINE__, #expr, (int)(expr), (int)(val)); \
-  return; \
-}
-
-#define ASSERT_EQ_S(expr, val) if (strcmp((expr), (val)) != 0) { \
-  printf("FAILED on line %d (%s equals %s, expected %s)\n", __LINE__, #expr, (const char*)(expr), (const char*)(val)); \
-  return; \
-}
-
-static void test_args()
+TEST(ConfigArgs, args)
 {
   int ret;
   std::vector<const char*> argv;
 
-  printf("%s: ", __func__);
-
   boolparam.setParam(true);
   intparam.setParam(1);
   strparam.setParam("test");
@@ -54,39 +41,35 @@ static void test_args()
   argv = {"prog" };
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 0);
-  ASSERT_EQ_I(ret, 0);
-  ASSERT_EQ_I(boolparam, true);
-  ASSERT_EQ_I(intparam, 1);
-  ASSERT_EQ_S(strparam, "test");
+  EXPECT_EQ(ret, 0);
+  EXPECT_EQ(boolparam, true);
+  EXPECT_EQ(intparam, 1);
+  EXPECT_STREQ(strparam, "test");
 
   // A bunch of standard arguments
   argv = {"prog", "arg1", "arg2", "arg3" };
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 2);
-  ASSERT_EQ_I(ret, 0);
-  ASSERT_EQ_I(boolparam, true);
-  ASSERT_EQ_I(intparam, 1);
-  ASSERT_EQ_S(strparam, "test");
+  EXPECT_EQ(ret, 0);
+  EXPECT_EQ(boolparam, true);
+  EXPECT_EQ(intparam, 1);
+  EXPECT_STREQ(strparam, "test");
 
   // A parameter without any dash
   argv = {"prog", "strparam", "intparam" };
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 0);
-  ASSERT_EQ_I(boolparam, true);
-  ASSERT_EQ_I(intparam, 1);
-  ASSERT_EQ_S(strparam, "test");
-
-  printf("OK\n");
+  EXPECT_EQ(ret, 0);
+  EXPECT_EQ(boolparam, true);
+  EXPECT_EQ(intparam, 1);
+  EXPECT_STREQ(strparam, "test");
 }
 
-static void test_none()
+TEST(ConfigArgs, noDash)
 {
   int ret;
   std::vector<const char*> argv;
 
-  printf("%s: ", __func__);
-
   boolparam.setParam(true);
   intparam.setParam(1);
   strparam.setParam("test");
@@ -95,39 +78,35 @@ static void test_none()
   argv = {"prog", "intparam=12", "34"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_I(intparam, 12);
+  EXPECT_EQ(ret, 1);
+  EXPECT_EQ(intparam, 12);
 
   // string argument
   argv = {"prog", "strparam=foo", "bar" };
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_S(strparam, "foo");
+  EXPECT_EQ(ret, 1);
+  EXPECT_STREQ(strparam, "foo");
 
   // empty string argument
   argv = {"prog", "strparam=", "bar" };
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_S(strparam, "");
+  EXPECT_EQ(ret, 1);
+  EXPECT_STREQ(strparam, "");
 
   // Bad parameter
   argv = {"prog", "fooparam=123"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 0);
-
-  printf("OK\n");
+  EXPECT_EQ(ret, 0);
 }
 
-static void test_single()
+TEST(ConfigArgs, singleDash)
 {
   int ret;
   std::vector<const char*> argv;
 
-  printf("%s: ", __func__);
-
   boolparam.setParam(true);
   intparam.setParam(1);
   strparam.setParam("test");
@@ -136,67 +115,63 @@ static void test_single()
   argv = {"prog", "-intparam", "12", "34"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 2);
-  ASSERT_EQ_I(intparam, 12);
+  EXPECT_EQ(ret, 2);
+  EXPECT_EQ(intparam, 12);
 
   // int argument with equals
   argv = {"prog", "-intparam=12", "34"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_I(intparam, 12);
+  EXPECT_EQ(ret, 1);
+  EXPECT_EQ(intparam, 12);
 
   // string argument
   argv = {"prog", "-strparam", "foo", "bar" };
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 2);
-  ASSERT_EQ_S(strparam, "foo");
+  EXPECT_EQ(ret, 2);
+  EXPECT_STREQ(strparam, "foo");
 
   // string argument with equals
   argv = {"prog", "-strparam=foo", "bar" };
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_S(strparam, "foo");
+  EXPECT_EQ(ret, 1);
+  EXPECT_STREQ(strparam, "foo");
 
   // empty string argument with equals
   argv = {"prog", "-strparam=", "bar" };
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_S(strparam, "");
+  EXPECT_EQ(ret, 1);
+  EXPECT_STREQ(strparam, "");
 
   // Missing argument
   intparam.setParam(1);
   argv = {"prog", "-intparam"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 0);
-  ASSERT_EQ_I(intparam, 1);
+  EXPECT_EQ(ret, 0);
+  EXPECT_EQ(intparam, 1);
 
   // Bad parameter
   argv = {"prog", "-fooparam", "123"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 0);
+  EXPECT_EQ(ret, 0);
 
   // Bad parameter with equals
   argv = {"prog", "-fooparam=123"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 0);
-
-  printf("OK\n");
+  EXPECT_EQ(ret, 0);
 }
 
-static void test_double()
+TEST(ConfigArgs, doubleDash)
 {
   int ret;
   std::vector<const char*> argv;
 
-  printf("%s: ", __func__);
-
   boolparam.setParam(true);
   intparam.setParam(1);
   strparam.setParam("test");
@@ -205,159 +180,146 @@ static void test_double()
   argv = {"prog", "--intparam", "12", "34"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 2);
-  ASSERT_EQ_I(intparam, 12);
+  EXPECT_EQ(ret, 2);
+  EXPECT_EQ(intparam, 12);
 
   // int argument with equals
   argv = {"prog", "--intparam=12", "34"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_I(intparam, 12);
+  EXPECT_EQ(ret, 1);
+  EXPECT_EQ(intparam, 12);
 
   // string argument
   argv = {"prog", "--strparam", "foo", "bar" };
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 2);
-  ASSERT_EQ_S(strparam, "foo");
+  EXPECT_EQ(ret, 2);
+  EXPECT_STREQ(strparam, "foo");
 
   // string argument with equals
   argv = {"prog", "--strparam=foo", "bar" };
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_S(strparam, "foo");
+  EXPECT_EQ(ret, 1);
+  EXPECT_STREQ(strparam, "foo");
 
   // empty string argument with equals
   argv = {"prog", "--strparam=", "bar" };
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_S(strparam, "");
+  EXPECT_EQ(ret, 1);
+  EXPECT_STREQ(strparam, "");
 
   // Missing argument
   intparam.setParam(1);
   argv = {"prog", "--intparam"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 0);
-  ASSERT_EQ_I(intparam, 1);
+  EXPECT_EQ(ret, 0);
+  EXPECT_EQ(intparam, 1);
 
   // Bad parameter
   argv = {"prog", "--fooparam", "123"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 0);
+  EXPECT_EQ(ret, 0);
 
   // Bad parameter with equals
   argv = {"prog", "--fooparam=123"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 0);
-
-  printf("OK\n");
+  EXPECT_EQ(ret, 0);
 }
 
-static void test_bool()
+TEST(ConfigArgs, bool)
 {
   int ret;
   std::vector<const char*> argv;
 
-  printf("%s: ", __func__);
-
   // solo bool (single)
   boolparam.setParam(false);
   argv = {"prog", "-boolparam"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_I(boolparam, true);
+  EXPECT_EQ(ret, 1);
+  EXPECT_EQ(boolparam, true);
 
   // solo bool (double)
   boolparam.setParam(false);
   argv = {"prog", "--boolparam"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_I(boolparam, true);
+  EXPECT_EQ(ret, 1);
+  EXPECT_EQ(boolparam, true);
 
   // bool argument (single)
   boolparam.setParam(true);
   argv = {"prog", "-boolparam", "off", "on"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 2);
-  ASSERT_EQ_I(boolparam, false);
+  EXPECT_EQ(ret, 2);
+  EXPECT_EQ(boolparam, false);
 
   // bool argument (double)
   boolparam.setParam(true);
   argv = {"prog", "--boolparam", "off", "on"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 2);
-  ASSERT_EQ_I(boolparam, false);
+  EXPECT_EQ(ret, 2);
+  EXPECT_EQ(boolparam, false);
 
   // bool argument equals (single)
   boolparam.setParam(true);
   argv = {"prog", "-boolparam=off", "on"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_I(boolparam, false);
+  EXPECT_EQ(ret, 1);
+  EXPECT_EQ(boolparam, false);
 
   // bool argument equals (double)
   boolparam.setParam(true);
   argv = {"prog", "--boolparam=off", "on"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_I(boolparam, false);
+  EXPECT_EQ(ret, 1);
+  EXPECT_EQ(boolparam, false);
 
   // empty bool argument equals (single)
   boolparam.setParam(true);
   argv = {"prog", "-boolparam=", "on"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_I(boolparam, true);
+  EXPECT_EQ(ret, 1);
+  EXPECT_EQ(boolparam, true);
 
   // empty bool argument equals (double)
   boolparam.setParam(true);
   argv = {"prog", "--boolparam=", "on"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_I(boolparam, true);
+  EXPECT_EQ(ret, 1);
+  EXPECT_EQ(boolparam, true);
 
   // bool bad argument (single)
   boolparam.setParam(false);
   argv = {"prog", "-boolparam", "foo", "off"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_I(boolparam, true);
+  EXPECT_EQ(ret, 1);
+  EXPECT_EQ(boolparam, true);
 
   // bool bad argument (double)
   boolparam.setParam(false);
   argv = {"prog", "--boolparam", "foo", "off"};
   ret = core::Configuration::handleParamArg(argv.size(),
                                             (char**)argv.data(), 1);
-  ASSERT_EQ_I(ret, 1);
-  ASSERT_EQ_I(boolparam, true);
-
-  printf("OK\n");
+  EXPECT_EQ(ret, 1);
+  EXPECT_EQ(boolparam, true);
 }
 
-int main(int /*argc*/, char** /*argv*/)
+int main(int argc, char** argv)
 {
-  printf("Configuration argument handling test\n");
-
-  test_args();
-  test_none();
-  test_single();
-  test_double();
-  test_bool();
-
-  return 0;
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
 }