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 {
 

[pneubeck (no reviews), 2013/05/16 08:21:07]

could be network_event_log namespace, simplifying the rest of the file.

[stevenjb, 2013/05/16 17:09:53]

I prefer to explicitly qualify global namespaced methods, even in the unit test,
but I think for the types you're right.
Done.

+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(network_event_log::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(network_event_log::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");
+  network_event_log::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(
+      "file1:1 event1: description1\n"
+      "file2:2 event2: description2\n"
+      "file3:3 event3: description3 (2)\n");
+  std::string output_oldest_first = GetLogString(
       network_event_log::OLDEST_FIRST, 0);
-  output_oldest_first = SkipTime(output_oldest_first);
   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(
+      "file2:2 event2: description2\n"
+      "file3:3 event3: description3 (2)\n");
+  std::string output_oldest_first_short = GetLogString(
       network_event_log::OLDEST_FIRST, 2);
-  output_oldest_first_short = SkipTime(output_oldest_first_short);
   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(
+      "file3:3 event3: description3 (2)\n"
+      "file2:2 event2: description2\n"
+      "file1:1 event1: description1\n");
+  std::string output_newest_first = GetLogString(
       network_event_log::NEWEST_FIRST, 0);
-  output_newest_first = SkipTime(output_newest_first);
   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(
+      "file3:3 event3: description3 (2)\n"
+      "file2:2 event2: description2\n");
+  std::string output_newest_first_short = GetLogString(
       network_event_log::NEWEST_FIRST, 2);
-  output_newest_first_short = SkipTime(output_newest_first_short);
   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);
+  for (size_t i = 0; i < entries_to_add; ++i) {
+    network_event_log::internal::AddEntry(
+        "test", 1, network_event_log::LOG_LEVEL_EVENT,
+        base::StringPrintf("event_%"PRIuS, i), "");
+  }
+  std::string output = GetLogString(network_event_log::OLDEST_FIRST, 0);
   size_t output_lines = CountLines(output);
   EXPECT_EQ(network_event_log::kMaxNetworkEventLogEntries, output_lines);
 }
 
+TEST_F(NetworkEventLogTest, TestStringFormat) {
+  network_event_log::internal::AddEntry(
+      "file", 0, network_event_log::LOG_LEVEL_ERROR, "event0", "description");
+  EXPECT_EQ("file:0 event0\n",
+            network_event_log::GetAsString(
+                network_event_log::OLDEST_FIRST,
+                "file",
+                kDefaultLevel, 1));
+  EXPECT_EQ("[time] event0\n",
+            SkipTime(network_event_log::GetAsString(
+                network_event_log::OLDEST_FIRST,
+                "time",
+                kDefaultLevel, 1)));
+  EXPECT_EQ("event0: description\n",
+            network_event_log::GetAsString(
+                network_event_log::OLDEST_FIRST,
+                "desc",
+                kDefaultLevel, 1));
+  EXPECT_EQ("event0\n",
+            network_event_log::GetAsString(
+                network_event_log::OLDEST_FIRST,
+                "",
+                kDefaultLevel, 1));
+  EXPECT_EQ("<b>event0</b>\n",
+            network_event_log::GetAsString(
+                network_event_log::OLDEST_FIRST,
+                "html",
+                kDefaultLevel, 1));
+  EXPECT_EQ("[time] file:0 event0: description\n",
+            SkipTime(network_event_log::GetAsString(
+                network_event_log::OLDEST_FIRST,
+                "file,time,desc",
+                kDefaultLevel, 1)));
+}
+
+namespace {
+
+void AddTestEvent(network_event_log::LogLevel level, const std::string& event) {
+  network_event_log::internal::AddEntry("file", 0, level, event, "description");
+}
+
+}  // namespace
+
+TEST_F(NetworkEventLogTest, TestLogLevel) {
+  AddTestEvent(network_event_log::LOG_LEVEL_ERROR, "error1");
+  AddTestEvent(network_event_log::LOG_LEVEL_ERROR, "error2");
+  AddTestEvent(network_event_log::LOG_LEVEL_EVENT, "event3");
+  AddTestEvent(network_event_log::LOG_LEVEL_ERROR, "error4");
+  AddTestEvent(network_event_log::LOG_LEVEL_EVENT, "event5");
+  AddTestEvent(network_event_log::LOG_LEVEL_DEBUG, "debug6");
+
+  std::string output;
+  output = network_event_log::GetAsString(
+      network_event_log::OLDEST_FIRST, "",
+      network_event_log::LOG_LEVEL_ERROR, 0);
+  EXPECT_EQ(3u, CountLines(output));
+  output = network_event_log::GetAsString(
+      network_event_log::OLDEST_FIRST, "",
+      network_event_log::LOG_LEVEL_EVENT, 0);
+  EXPECT_EQ(5u, CountLines(output));
+  output = network_event_log::GetAsString(
+      network_event_log::OLDEST_FIRST, "",
+      network_event_log::LOG_LEVEL_DEBUG, 0);
+  EXPECT_EQ(6u, CountLines(output));
+
+  // Test max_level. Get only the ERROR entries.
+  output = network_event_log::GetAsString(
+      network_event_log::OLDEST_FIRST, "",
+      network_event_log::LOG_LEVEL_ERROR, 0);
+  EXPECT_EQ("error1\nerror2\nerror4\n", output);
+}
+
+TEST_F(NetworkEventLogTest, TestMaxEvents) {
+  AddTestEvent(network_event_log::LOG_LEVEL_EVENT, "event1");
+  AddTestEvent(network_event_log::LOG_LEVEL_ERROR, "error2");
+  AddTestEvent(network_event_log::LOG_LEVEL_EVENT, "event3");
+  AddTestEvent(network_event_log::LOG_LEVEL_ERROR, "error4");
+  AddTestEvent(network_event_log::LOG_LEVEL_EVENT, "event5");
+
+  std::string output = network_event_log::GetAsString(
+      network_event_log::OLDEST_FIRST, "",

[pneubeck (no reviews), 2013/05/16 08:21:07]

please test the combination with NEWEST_FIRST as well.

[stevenjb, 2013/05/16 17:09:53]

Done.

+      network_event_log::LOG_LEVEL_ERROR, 1);
+  EXPECT_EQ("error4\n", output);
+
+  output = network_event_log::GetAsString(
+      network_event_log::OLDEST_FIRST, "",
+      network_event_log::LOG_LEVEL_ERROR, 2);
+  EXPECT_EQ("error2\nerror4\n", output);
+
+  output = network_event_log::GetAsString(
+      network_event_log::OLDEST_FIRST, "",
+      network_event_log::LOG_LEVEL_EVENT, 3);
+  EXPECT_EQ("event3\nerror4\nevent5\n", output);
+
+  output = network_event_log::GetAsString(
+      network_event_log::OLDEST_FIRST, "",
+      network_event_log::LOG_LEVEL_EVENT, 4);
+  EXPECT_EQ("error2\nevent3\nerror4\nevent5\n", output);
+
+  output = network_event_log::GetAsString(
+      network_event_log::OLDEST_FIRST, "",
+      network_event_log::LOG_LEVEL_EVENT, 5);
+  EXPECT_EQ("event1\nerror2\nevent3\nerror4\nevent5\n", output);
+}
+
 }  // namespace chromeos