chromeos/network/network_event_log_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chromeos/network/network_event_log.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/basictypes.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/format_macros.h"
  12 #include "base/strings/string_split.h"
  13 #include "base/strings/stringprintf.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace chromeos {
  17 namespace network_event_log {
  18
  19 namespace {
  20
  21 network_event_log::LogLevel kDefaultLevel = network_event_log::LOG_LEVEL_EVENT;
  22
  23 }  // namespace
  24
  25 class NetworkEventLogTest : public testing::Test {
  26  public:
  27   NetworkEventLogTest() {
  28   }
  29
  30   virtual void SetUp() override {
  31     network_event_log::Initialize();
  32   }
  33
  34   virtual void TearDown() override {
  35     network_event_log::Shutdown();
  36   }
  37
  38  protected:
  39   std::string SkipTime(const std::string& input) {
  40     std::string output;
  41     std::vector<std::string> lines;
  42     base::SplitString(input, '\n', &lines);
  43     for (size_t i = 0; i < lines.size(); ++i) {
  44       size_t n = lines[i].find(']');
  45       if (n != std::string::npos)
  46         output += "[time] " + lines[i].substr(n+2) + '\n';
  47       else
  48         output += lines[i];
  49     }
  50     return output;
  51   }
  52
  53   size_t CountLines(const std::string& input) {
  54     return std::count(input.begin(), input.end(), '\n');
  55   }
  56
  57   std::string GetLogString(StringOrder order, size_t max_events) {
  58     return network_event_log::GetAsString(
  59         order, "file,desc", kDefaultLevel, max_events);
  60   }
  61
  62  private:
  63   DISALLOW_COPY_AND_ASSIGN(NetworkEventLogTest);
  64 };
  65
  66 TEST_F(NetworkEventLogTest, TestNetworkEvents) {
  67   std::string output_none = GetLogString(OLDEST_FIRST, 0);
  68   EXPECT_EQ("No Log Entries.", output_none);
  69
  70   LogLevel level = kDefaultLevel;
  71   network_event_log::internal::AddEntry(
  72       "file1", 1, level, "event1", "description1");
  73   network_event_log::internal::AddEntry(
  74       "file2", 2, level, "event2", "description2");
  75   network_event_log::internal::AddEntry(
  76       "file3", 3, level, "event3", "description3");
  77   network_event_log::internal::AddEntry(
  78       "file3", 3, level, "event3", "description3");
  79
  80   const std::string expected_output_oldest_first(
  81       "file1:1 event1: description1\n"
  82       "file2:2 event2: description2\n"
  83       "file3:3 event3: description3 (2)\n");
  84   std::string output_oldest_first = GetLogString(OLDEST_FIRST, 0);
  85   EXPECT_EQ(expected_output_oldest_first, output_oldest_first);
  86
  87   const std::string expected_output_oldest_first_short(
  88       "file2:2 event2: description2\n"
  89       "file3:3 event3: description3 (2)\n");
  90   std::string output_oldest_first_short = GetLogString(OLDEST_FIRST, 2);
  91   EXPECT_EQ(expected_output_oldest_first_short, output_oldest_first_short);
  92
  93   const std::string expected_output_newest_first(
  94       "file3:3 event3: description3 (2)\n"
  95       "file2:2 event2: description2\n"
  96       "file1:1 event1: description1\n");
  97   std::string output_newest_first = GetLogString(NEWEST_FIRST, 0);
  98   EXPECT_EQ(expected_output_newest_first, output_newest_first);
  99
 100   const std::string expected_output_newest_first_short(
 101       "file3:3 event3: description3 (2)\n"
 102       "file2:2 event2: description2\n");
 103   std::string output_newest_first_short = GetLogString(NEWEST_FIRST, 2);
 104   EXPECT_EQ(expected_output_newest_first_short, output_newest_first_short);
 105 }
 106
 107 TEST_F(NetworkEventLogTest, TestMaxNetworkEvents) {
 108   const size_t max_entries = network_event_log::internal::GetMaxLogEntries();
 109   const size_t entries_to_add = max_entries + 3;
 110   for (size_t i = 0; i < entries_to_add; ++i) {
 111     network_event_log::internal::AddEntry(
 112         "test", 1, LOG_LEVEL_EVENT,
 113         base::StringPrintf("event_%" PRIuS, i), "");
 114   }
 115   std::string output = GetLogString(OLDEST_FIRST, 0);
 116   size_t output_lines = CountLines(output);
 117   EXPECT_EQ(max_entries, output_lines);
 118 }
 119
 120 TEST_F(NetworkEventLogTest, TestStringFormat) {
 121   network_event_log::internal::AddEntry(
 122       "file", 0, LOG_LEVEL_ERROR, "event0", "description");
 123   EXPECT_EQ("file:0 event0\n", network_event_log::GetAsString(
 124       OLDEST_FIRST, "file", kDefaultLevel, 1));
 125   EXPECT_EQ("[time] event0\n", SkipTime(network_event_log::GetAsString(
 126       OLDEST_FIRST, "time", kDefaultLevel, 1)));
 127   EXPECT_EQ("event0: description\n", network_event_log::GetAsString(
 128       OLDEST_FIRST, "desc", kDefaultLevel, 1));
 129   EXPECT_EQ("event0\n", network_event_log::GetAsString(
 130       OLDEST_FIRST, "", kDefaultLevel, 1));
 131   EXPECT_EQ("<b><i>event0</i></b>\n", network_event_log::GetAsString(
 132       OLDEST_FIRST, "html", kDefaultLevel, 1));
 133   EXPECT_EQ("[time] file:0 event0: description\n",
 134             SkipTime(network_event_log::GetAsString(
 135                 OLDEST_FIRST, "file,time,desc", kDefaultLevel, 1)));
 136
 137   network_event_log::internal::AddEntry(
 138       "file", 0, LOG_LEVEL_DEBUG, "event1", "description");
 139   EXPECT_EQ("[time] file:0 <i>event1: description</i>\n",
 140             SkipTime(network_event_log::GetAsString(
 141                 OLDEST_FIRST, "file,time,desc,html", LOG_LEVEL_DEBUG, 1)));
 142 }
 143
 144 namespace {
 145
 146 void AddTestEvent(LogLevel level, const std::string& event) {
 147   network_event_log::internal::AddEntry("file", 0, level, event, "description");
 148 }
 149
 150 }  // namespace
 151
 152 TEST_F(NetworkEventLogTest, TestLogLevel) {
 153   AddTestEvent(LOG_LEVEL_ERROR, "error1");
 154   AddTestEvent(LOG_LEVEL_ERROR, "error2");
 155   AddTestEvent(LOG_LEVEL_EVENT, "event3");
 156   AddTestEvent(LOG_LEVEL_ERROR, "error4");
 157   AddTestEvent(LOG_LEVEL_EVENT, "event5");
 158   AddTestEvent(LOG_LEVEL_DEBUG, "debug6");
 159
 160   std::string output;
 161   output = network_event_log::GetAsString(
 162       OLDEST_FIRST, "", LOG_LEVEL_ERROR, 0);
 163   EXPECT_EQ(3u, CountLines(output));
 164   output = network_event_log::GetAsString(
 165       OLDEST_FIRST, "", LOG_LEVEL_EVENT, 0);
 166   EXPECT_EQ(5u, CountLines(output));
 167   output = network_event_log::GetAsString(
 168       OLDEST_FIRST, "", LOG_LEVEL_DEBUG, 0);
 169   EXPECT_EQ(6u, CountLines(output));
 170
 171   // Test max_level. Get only the ERROR entries.
 172   output = network_event_log::GetAsString(
 173       OLDEST_FIRST, "", LOG_LEVEL_ERROR, 0);
 174   EXPECT_EQ("error1\nerror2\nerror4\n", output);
 175 }
 176
 177 TEST_F(NetworkEventLogTest, TestMaxEvents) {
 178   AddTestEvent(LOG_LEVEL_EVENT, "event1");
 179   AddTestEvent(LOG_LEVEL_ERROR, "error2");
 180   AddTestEvent(LOG_LEVEL_EVENT, "event3");
 181   AddTestEvent(LOG_LEVEL_ERROR, "error4");
 182   AddTestEvent(LOG_LEVEL_EVENT, "event5");
 183
 184   // Oldest first
 185   EXPECT_EQ("error4\n", network_event_log::GetAsString(
 186       OLDEST_FIRST, "", LOG_LEVEL_ERROR, 1));
 187
 188   EXPECT_EQ("error2\nerror4\n", network_event_log::GetAsString(
 189       OLDEST_FIRST, "", LOG_LEVEL_ERROR, 2));
 190
 191   EXPECT_EQ("event3\nerror4\nevent5\n", network_event_log::GetAsString(
 192       OLDEST_FIRST, "", LOG_LEVEL_EVENT, 3));
 193
 194   EXPECT_EQ("error2\nevent3\nerror4\nevent5\n", network_event_log::GetAsString(
 195       OLDEST_FIRST, "", LOG_LEVEL_EVENT, 4));
 196
 197   EXPECT_EQ("event1\nerror2\nevent3\nerror4\nevent5\n",
 198             network_event_log::GetAsString(
 199                 OLDEST_FIRST, "", LOG_LEVEL_EVENT, 5));
 200
 201   // Newest first
 202   EXPECT_EQ("error4\n", network_event_log::GetAsString(
 203       NEWEST_FIRST, "", LOG_LEVEL_ERROR, 1));
 204
 205   EXPECT_EQ("error4\nerror2\n", network_event_log::GetAsString(
 206       NEWEST_FIRST, "", LOG_LEVEL_ERROR, 2));
 207
 208   EXPECT_EQ("event5\nerror4\nevent3\n", network_event_log::GetAsString(
 209       NEWEST_FIRST, "", LOG_LEVEL_EVENT, 3));
 210
 211   EXPECT_EQ("event5\nerror4\nevent3\nerror2\n", network_event_log::GetAsString(
 212       NEWEST_FIRST, "", LOG_LEVEL_EVENT, 4));
 213
 214   EXPECT_EQ("event5\nerror4\nevent3\nerror2\nevent1\n",
 215             network_event_log::GetAsString(
 216                 NEWEST_FIRST, "", LOG_LEVEL_EVENT, 5));
 217 }
 218
 219 TEST_F(NetworkEventLogTest, TestMaxErrors) {
 220   network_event_log::internal::SetMaxLogEntries(4);
 221   AddTestEvent(LOG_LEVEL_EVENT, "event1");
 222   AddTestEvent(LOG_LEVEL_ERROR, "error2");
 223   AddTestEvent(LOG_LEVEL_EVENT, "event3");
 224   AddTestEvent(LOG_LEVEL_ERROR, "error4");
 225   AddTestEvent(LOG_LEVEL_EVENT, "event5");
 226   AddTestEvent(LOG_LEVEL_EVENT, "event6");
 227   EXPECT_EQ("error2\nerror4\nevent5\nevent6\n", network_event_log::GetAsString(
 228       OLDEST_FIRST, "", LOG_LEVEL_DEBUG, 0));
 229   network_event_log::internal::SetMaxLogEntries(0);
 230   EXPECT_EQ("No Log Entries.", network_event_log::GetAsString(
 231       OLDEST_FIRST, "", LOG_LEVEL_DEBUG, 0));
 232   network_event_log::internal::SetMaxLogEntries(4);
 233   AddTestEvent(LOG_LEVEL_ERROR, "error1");
 234   AddTestEvent(LOG_LEVEL_ERROR, "error2");
 235   AddTestEvent(LOG_LEVEL_ERROR, "error3");
 236   AddTestEvent(LOG_LEVEL_ERROR, "error4");
 237   AddTestEvent(LOG_LEVEL_EVENT, "event5");
 238   AddTestEvent(LOG_LEVEL_EVENT, "event6");
 239   EXPECT_EQ("error3\nerror4\nevent5\nevent6\n", network_event_log::GetAsString(
 240       OLDEST_FIRST, "", LOG_LEVEL_DEBUG, 0));
 241 }
 242
 243 }  // namespace network_event_log
 244 }  // namespace chromeos