Refactor Logger test am: 4e34847ac3

Original change: https://android-review.googlesource.com/c/platform/test/dittosuite/+/2943526

Change-Id: I838ef26d36e6502d8279250ab6f38f2f6c30d638
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

1 files changed, 65 insertions, 41 deletions

diff --git a/test/logger_test.cpp b/test/logger_test.cpp
index 3da5439..094246d 100644
--- a/test/logger_test.cpp
+++ b/test/logger_test.cpp
@@ -19,6 +19,18 @@
 
 namespace dittosuite {
 
+class TestLogger : public Logger {};
+
+TEST(DittoLogger, DefaultVerbosityIsInfo) {
+  TestLogger logger;
+
+  LogLevel log_level = logger.GetLogLevel();
+
+  ASSERT_EQ(LogLevel::kInfo, log_level);
+}
+
+/* TODO this test should be properly refactored (split and mocked) to make sure
+the strings are written to the logs. */
 TEST(DittoLogger, SimpleLog) {
   for (int i = 10; i <= 11; i++) {
     Logger::GetInstance().SetLogLevel(LogLevel::kError);
@@ -34,56 +46,68 @@ TEST(DittoLogger, SimpleLog) {
   }
 }
 
-TEST(DittoLogger, SetAndGetLevel) {
-  for (const auto l : {LogLevel::kVerbose, LogLevel::kDebug, LogLevel::kInfo, LogLevel::kWarning,
-                       LogLevel::kError}) {
-    Logger::GetInstance().SetLogLevel(l);
-    ASSERT_EQ(Logger::GetInstance().GetLogLevel(), l);
-  }
-}
+TEST(DittoLogger, LoggerPError) {
+  TestLogger logger;
 
-TEST(DittoLogger, SetAndGetStream) {
-  for (const auto s : {LogStream::kStdout, LogStream::kLogcat}) {
-    Logger::GetInstance().SetLogStream(s);
-    ASSERT_EQ(Logger::GetInstance().GetLogStream(), s);
-  }
-}
+  FILE* pFile = fopen("nonexistent.txt", "re");
 
-TEST(DittoLogger, LoggerPError) {
-  FILE* pFile;
-  std::string file_name = "nonexistent.txt";
-  pFile = fopen(file_name.c_str(), "re");
-  if (pFile == nullptr) {
-    PLOGE("Cannot open \"" + file_name + "\"");
-  }
+  ASSERT_EQ(nullptr, pFile);
 }
 
-TEST(DittoLogger, DefaultVerbosityIsInfo) {
-  ASSERT_EQ(Logger::GetInstance().GetLogLevel(), LogLevel::kInfo);
-}
+class DittoLoggerStreamUpdate : public testing::TestWithParam<dittosuite::LogStream> {};
+
+TEST_P(DittoLoggerStreamUpdate, SetStream) {
+  TestLogger logger;
 
-TEST(DittoLogger, ArgumentsToLevelString) {
-  ASSERT_EQ(ArgToLogLevel("VERBOSE"), LogLevel::kVerbose);
-  ASSERT_EQ(ArgToLogLevel("DEBUG"), LogLevel::kDebug);
-  ASSERT_EQ(ArgToLogLevel("INFO"), LogLevel::kInfo);
-  ASSERT_EQ(ArgToLogLevel("WARNING"), LogLevel::kWarning);
-  ASSERT_EQ(ArgToLogLevel("ERROR"), LogLevel::kError);
-  ASSERT_EQ(ArgToLogLevel("FATAL"), LogLevel::kFatal);
+  logger.SetLogStream(GetParam());
+  LogStream log_stream = logger.GetLogStream();
+
+  ASSERT_EQ(GetParam(), log_stream);
 }
 
-TEST(DittoLogger, ArgumentsToLevelNumber) {
-  ASSERT_EQ(ArgToLogLevel("5"), LogLevel::kVerbose);
-  ASSERT_EQ(ArgToLogLevel("4"), LogLevel::kDebug);
-  ASSERT_EQ(ArgToLogLevel("3"), LogLevel::kInfo);
-  ASSERT_EQ(ArgToLogLevel("2"), LogLevel::kWarning);
-  ASSERT_EQ(ArgToLogLevel("1"), LogLevel::kError);
-  ASSERT_EQ(ArgToLogLevel("0"), LogLevel::kFatal);
+INSTANTIATE_TEST_SUITE_P(Streams, DittoLoggerStreamUpdate,
+                         testing::Values(LogStream::kStdout, LogStream::kLogcat));
+
+class DittoLoggerLevelUpdate : public testing::TestWithParam<dittosuite::LogLevel> {};
+
+TEST_P(DittoLoggerLevelUpdate, SetLevel) {
+  TestLogger logger;
+
+  logger.SetLogLevel(GetParam());
+  LogLevel log_level = logger.GetLogLevel();
+
+  ASSERT_EQ(GetParam(), log_level);
 }
 
-TEST(DittoLogger, ArgumentsToLevelInvalid) {
-  ASSERT_EQ(ArgToLogLevel("6"), LogLevel::kInfo);
-  ASSERT_EQ(ArgToLogLevel(""), LogLevel::kInfo);
-  ASSERT_EQ(ArgToLogLevel("UNKNOWN"), LogLevel::kInfo);
+INSTANTIATE_TEST_SUITE_P(Levels, DittoLoggerLevelUpdate,
+                         testing::Values(LogLevel::kInfo, LogLevel::kWarning, LogLevel::kError,
+                                         LogLevel::kFatal, LogLevel::kVerbose, LogLevel::kDebug));
+
+class DittoLoggerLevel
+    : public testing::TestWithParam<std::pair<std::string_view, dittosuite::LogLevel>> {};
+
+TEST_P(DittoLoggerLevel, ArgumentsToLevelStringParam) {
+  TestLogger logger;
+
+  LogLevel log_level = ArgToLogLevel(GetParam().first);
+
+  ASSERT_EQ(GetParam().second, log_level);
 }
 
+INSTANTIATE_TEST_SUITE_P(
+    StringMatchesPB, DittoLoggerLevel,
+    testing::Values(
+        std::make_pair("VERBOSE", LogLevel::kVerbose), std::make_pair("DEBUG", LogLevel::kDebug),
+        std::make_pair("INFO", LogLevel::kInfo), std::make_pair("WARNING", LogLevel::kWarning),
+        std::make_pair("ERROR", LogLevel::kError), std::make_pair("FATAL", LogLevel::kFatal),
+        std::make_pair("5", LogLevel::kVerbose), std::make_pair("4", LogLevel::kDebug),
+        std::make_pair("3", LogLevel::kInfo), std::make_pair("2", LogLevel::kWarning),
+        std::make_pair("1", LogLevel::kError), std::make_pair("0", LogLevel::kFatal)));
+
+INSTANTIATE_TEST_SUITE_P(StringMatchesNoPBReturnsInfo, DittoLoggerLevel,
+                         testing::Values(std::make_pair("6", LogLevel::kInfo),
+                                         std::make_pair("-1", LogLevel::kInfo),
+                                         std::make_pair("UNKNOWN", LogLevel::kInfo),
+                                         std::make_pair("", LogLevel::kInfo)));
+
 }  // namespace dittosuite