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::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::AddEntry("file1", 1, level, "event1", "description1");
+  network_event_log::AddEntry("file2", 2, level, "event2", "description2");
+  network_event_log::AddEntry("file3", 3, level, "event3", "description3");
+  network_event_log::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",
+  for (size_t i = 0; i < entries_to_add; ++i) {
+    network_event_log::AddEntry("test", 1, network_event_log::LOG_LEVEL_EVENT,
                                 base::StringPrintf("event_%"PRIuS, i), "");
-
-  std::string output = GetAsString(network_event_log::OLDEST_FIRST, 0);
+  }
+  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::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 AddEventsAtLevel(network_event_log::LogLevel level, int num_events) {
+  static int event_index = 0;
+  for (int i = 0; i < num_events; ++i) {
+    std::string event = base::StringPrintf("event%d", event_index++);
+    network_event_log::AddEntry("file", 0, level, event, "description");
+  }
+}
+
+}  // namespace
+
+TEST_F(NetworkEventLogTest, TestLogLevel) {
+  AddEventsAtLevel(network_event_log::LOG_LEVEL_ERROR, 3);
+  AddEventsAtLevel(network_event_log::LOG_LEVEL_EVENT, 2);
+  AddEventsAtLevel(network_event_log::LOG_LEVEL_DEBUG, 1);

[pneubeck (no reviews), 2013/05/13 13:16:25]

please add two more groups, so that there are two separated groups (also not at
the border) which are filtered out in the subsequent tests. something like:

a:0 b:2 c:0 d:0 e:1 f:0  ==(last 2, =< 0)==> d:0 f:0

[stevenjb, 2013/05/13 19:36:39]

Not clear what you meant by a,b,c,etc, but I separated the max test, made it
less trivial, and fixed the code to address the logic error that gaurav pointed
out.

+
+  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("event0\nevent1\nevent2\n", output);
+
+  // Test max_events with max_level. Get the 2 most recent ERROR entries.
+  output = network_event_log::GetAsString(
+      network_event_log::OLDEST_FIRST, "",
+      network_event_log::LOG_LEVEL_ERROR, 2);
+  EXPECT_EQ("event1\nevent2\n", output);
+}
+
 }  // namespace chromeos