Re-factor network_event_log

chromeos/network/network_event_log_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chromeos/network/network_event_log.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_split.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
+namespace network_event_log {
+
+namespace {
+
+network_event_log::LogLevel kDefaultLevel = network_event_log::LOG_LEVEL_EVENT;
+
+}  // namespace
 
 class NetworkEventLogTest : public testing::Test {
  public:
   NetworkEventLogTest() {
   }
 
   virtual void SetUp() OVERRIDE {
     network_event_log::Initialize();
   }
 
   virtual void TearDown() OVERRIDE {
     network_event_log::Shutdown();
   }
 
  protected:
   std::string SkipTime(const std::string& input) {
     std::string output;
     std::vector<std::string> lines;
     base::SplitString(input, '\n', &lines);
     for (size_t i = 0; i < lines.size(); ++i) {
       size_t n = lines[i].find(']');
       if (n != std::string::npos)
-        output += lines[i].substr(n+2) + '\n';
+        output += "[time] " + lines[i].substr(n+2) + '\n';
+      else
+        output += lines[i];
     }
     return output;
   }
 
   size_t CountLines(const std::string& input) {
     return std::count(input.begin(), input.end(), '\n');
   }
 
+  std::string GetLogString(StringOrder order, size_t max_events) {
+    return network_event_log::GetAsString(
+        order, "file,desc", kDefaultLevel, max_events);
+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkEventLogTest);
 };
 
 TEST_F(NetworkEventLogTest, TestNetworkEvents) {
-  std::string output_none = network_event_log::GetAsString(
-      network_event_log::OLDEST_FIRST, 0);
+  std::string output_none = GetLogString(OLDEST_FIRST, 0);
   EXPECT_EQ("No Log Entries.", output_none);
 
-  network_event_log::AddEntry("module1", "event1", "description1");
-  network_event_log::AddEntry("module2", "event2", "description2");
-  network_event_log::AddEntry("module3", "event3", "description3");
-  network_event_log::AddEntry("module3", "event3", "description3");
+  LogLevel level = kDefaultLevel;
+  network_event_log::internal::AddEntry(
+      "file1", 1, level, "event1", "description1");
+  network_event_log::internal::AddEntry(
+      "file2", 2, level, "event2", "description2");
+  network_event_log::internal::AddEntry(
+      "file3", 3, level, "event3", "description3");
+  network_event_log::internal::AddEntry(
+      "file3", 3, level, "event3", "description3");
 
   const std::string expected_output_oldest_first(
-      "module1:event1: description1\n"
-      "module2:event2: description2\n"
-      "module3:event3: description3 (2)\n");
-  std::string output_oldest_first = network_event_log::GetAsString(
-      network_event_log::OLDEST_FIRST, 0);
-  output_oldest_first = SkipTime(output_oldest_first);
+      "file1:1 event1: description1\n"
+      "file2:2 event2: description2\n"
+      "file3:3 event3: description3 (2)\n");
+  std::string output_oldest_first = GetLogString(OLDEST_FIRST, 0);
   EXPECT_EQ(expected_output_oldest_first, output_oldest_first);
 
   const std::string expected_output_oldest_first_short(
-      "module2:event2: description2\n"
-      "module3:event3: description3 (2)\n");
-  std::string output_oldest_first_short = network_event_log::GetAsString(
-      network_event_log::OLDEST_FIRST, 2);
-  output_oldest_first_short = SkipTime(output_oldest_first_short);
+      "file2:2 event2: description2\n"
+      "file3:3 event3: description3 (2)\n");
+  std::string output_oldest_first_short = GetLogString(OLDEST_FIRST, 2);
   EXPECT_EQ(expected_output_oldest_first_short, output_oldest_first_short);
 
   const std::string expected_output_newest_first(
-      "module3:event3: description3 (2)\n"
-      "module2:event2: description2\n"
-      "module1:event1: description1\n");
-  std::string output_newest_first = network_event_log::GetAsString(
-      network_event_log::NEWEST_FIRST, 0);
-  output_newest_first = SkipTime(output_newest_first);
+      "file3:3 event3: description3 (2)\n"
+      "file2:2 event2: description2\n"
+      "file1:1 event1: description1\n");
+  std::string output_newest_first = GetLogString(NEWEST_FIRST, 0);
   EXPECT_EQ(expected_output_newest_first, output_newest_first);
 
   const std::string expected_output_newest_first_short(
-      "module3:event3: description3 (2)\n"
-      "module2:event2: description2\n");
-  std::string output_newest_first_short = network_event_log::GetAsString(
-      network_event_log::NEWEST_FIRST, 2);
-  output_newest_first_short = SkipTime(output_newest_first_short);
+      "file3:3 event3: description3 (2)\n"
+      "file2:2 event2: description2\n");
+  std::string output_newest_first_short = GetLogString(NEWEST_FIRST, 2);
   EXPECT_EQ(expected_output_newest_first_short, output_newest_first_short);
 }
 
 TEST_F(NetworkEventLogTest, TestMaxNetworkEvents) {
   const size_t entries_to_add =
-      network_event_log::kMaxNetworkEventLogEntries + 3;
-  for (size_t i = 0; i < entries_to_add; ++i)
-    network_event_log::AddEntry("test",
-                                base::StringPrintf("event_%"PRIuS, i), "");
-
-  std::string output = GetAsString(network_event_log::OLDEST_FIRST, 0);
+      kMaxNetworkEventLogEntries + 3;
+  for (size_t i = 0; i < entries_to_add; ++i) {
+    network_event_log::internal::AddEntry(
+        "test", 1, LOG_LEVEL_EVENT,
+        base::StringPrintf("event_%"PRIuS, i), "");
+  }
+  std::string output = GetLogString(OLDEST_FIRST, 0);
   size_t output_lines = CountLines(output);
-  EXPECT_EQ(network_event_log::kMaxNetworkEventLogEntries, output_lines);
+  EXPECT_EQ(kMaxNetworkEventLogEntries, output_lines);
 }
 
+TEST_F(NetworkEventLogTest, TestStringFormat) {
+  network_event_log::internal::AddEntry(
+      "file", 0, LOG_LEVEL_ERROR, "event0", "description");
+  EXPECT_EQ("file:0 event0\n", network_event_log::GetAsString(
+      OLDEST_FIRST, "file", kDefaultLevel, 1));
+  EXPECT_EQ("[time] event0\n", SkipTime(network_event_log::GetAsString(
+      OLDEST_FIRST, "time", kDefaultLevel, 1)));
+  EXPECT_EQ("event0: description\n", network_event_log::GetAsString(
+      OLDEST_FIRST, "desc", kDefaultLevel, 1));
+  EXPECT_EQ("event0\n", network_event_log::GetAsString(
+      OLDEST_FIRST, "", kDefaultLevel, 1));
+  EXPECT_EQ("<b>event0</b>\n", network_event_log::GetAsString(
+      OLDEST_FIRST, "html", kDefaultLevel, 1));
+  EXPECT_EQ("[time] file:0 event0: description\n",
+            SkipTime(network_event_log::GetAsString(
+                OLDEST_FIRST, "file,time,desc", kDefaultLevel, 1)));
+
+  network_event_log::internal::AddEntry(
+      "file", 0, LOG_LEVEL_DEBUG, "event1", "description");
+  EXPECT_EQ("[time] file:0 <i>event1: description</i>\n",
+            SkipTime(network_event_log::GetAsString(
+                OLDEST_FIRST, "file,time,desc,html", LOG_LEVEL_DEBUG, 1)));
+}
+
+namespace {
+
+void AddTestEvent(LogLevel level, const std::string& event) {
+  network_event_log::internal::AddEntry("file", 0, level, event, "description");
+}
+
+}  // namespace
+
+TEST_F(NetworkEventLogTest, TestLogLevel) {
+  AddTestEvent(LOG_LEVEL_ERROR, "error1");
+  AddTestEvent(LOG_LEVEL_ERROR, "error2");
+  AddTestEvent(LOG_LEVEL_EVENT, "event3");
+  AddTestEvent(LOG_LEVEL_ERROR, "error4");
+  AddTestEvent(LOG_LEVEL_EVENT, "event5");
+  AddTestEvent(LOG_LEVEL_DEBUG, "debug6");
+
+  std::string output;
+  output = network_event_log::GetAsString(
+      OLDEST_FIRST, "", LOG_LEVEL_ERROR, 0);
+  EXPECT_EQ(3u, CountLines(output));
+  output = network_event_log::GetAsString(
+      OLDEST_FIRST, "", LOG_LEVEL_EVENT, 0);
+  EXPECT_EQ(5u, CountLines(output));
+  output = network_event_log::GetAsString(
+      OLDEST_FIRST, "", LOG_LEVEL_DEBUG, 0);
+  EXPECT_EQ(6u, CountLines(output));
+
+  // Test max_level. Get only the ERROR entries.
+  output = network_event_log::GetAsString(
+      OLDEST_FIRST, "", LOG_LEVEL_ERROR, 0);
+  EXPECT_EQ("error1\nerror2\nerror4\n", output);
+}
+
+TEST_F(NetworkEventLogTest, TestMaxEvents) {
+  AddTestEvent(LOG_LEVEL_EVENT, "event1");
+  AddTestEvent(LOG_LEVEL_ERROR, "error2");
+  AddTestEvent(LOG_LEVEL_EVENT, "event3");
+  AddTestEvent(LOG_LEVEL_ERROR, "error4");
+  AddTestEvent(LOG_LEVEL_EVENT, "event5");
+
+  // Oldest first
+  EXPECT_EQ("error4\n", network_event_log::GetAsString(
+      OLDEST_FIRST, "", LOG_LEVEL_ERROR, 1));
+
+  EXPECT_EQ("error2\nerror4\n", network_event_log::GetAsString(
+      OLDEST_FIRST, "", LOG_LEVEL_ERROR, 2));
+
+  EXPECT_EQ("event3\nerror4\nevent5\n", network_event_log::GetAsString(
+      OLDEST_FIRST, "", LOG_LEVEL_EVENT, 3));
+
+  EXPECT_EQ("error2\nevent3\nerror4\nevent5\n", network_event_log::GetAsString(
+      OLDEST_FIRST, "", LOG_LEVEL_EVENT, 4));
+
+  EXPECT_EQ("event1\nerror2\nevent3\nerror4\nevent5\n",
+            network_event_log::GetAsString(
+                OLDEST_FIRST, "", LOG_LEVEL_EVENT, 5));
+
+  // Newest first
+  EXPECT_EQ("error4\n", network_event_log::GetAsString(
+      NEWEST_FIRST, "", LOG_LEVEL_ERROR, 1));
+
+  EXPECT_EQ("error4\nerror2\n", network_event_log::GetAsString(
+      NEWEST_FIRST, "", LOG_LEVEL_ERROR, 2));
+
+  EXPECT_EQ("event5\nerror4\nevent3\n", network_event_log::GetAsString(
+      NEWEST_FIRST, "", LOG_LEVEL_EVENT, 3));
+
+  EXPECT_EQ("event5\nerror4\nevent3\nerror2\n", network_event_log::GetAsString(
+      NEWEST_FIRST, "", LOG_LEVEL_EVENT, 4));
+
+  EXPECT_EQ("event5\nerror4\nevent3\nerror2\nevent1\n",
+            network_event_log::GetAsString(
+                NEWEST_FIRST, "", LOG_LEVEL_EVENT, 5));
+}
+
+}  // namespace network_event_log
 }  // namespace chromeos