net/log/net_log_unittest.cc

   1 // Copyright (c) 2013 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 "net/log/net_log_unittest.h"
   6
   7 #include "base/bind.h"
   8 #include "base/memory/scoped_vector.h"
   9 #include "base/synchronization/waitable_event.h"
  10 #include "base/threading/simple_thread.h"
  11 #include "base/values.h"
  12 #include "net/base/net_errors.h"
  13
  14 namespace net {
  15
  16 namespace {
  17
  18 const int kThreads = 10;
  19 const int kEvents = 100;
  20
  21 base::Value* NetLogLevelCallback(NetLog::LogLevel log_level) {
  22   base::DictionaryValue* dict = new base::DictionaryValue();
  23   dict->SetInteger("log_level", log_level);
  24   return dict;
  25 }
  26
  27 TEST(NetLogTest, Basic) {
  28   CapturingNetLog net_log;
  29   CapturingNetLog::CapturedEntryList entries;
  30   net_log.GetEntries(&entries);
  31   EXPECT_EQ(0u, entries.size());
  32
  33   net_log.AddGlobalEntry(NetLog::TYPE_CANCELLED);
  34
  35   net_log.GetEntries(&entries);
  36   ASSERT_EQ(1u, entries.size());
  37   EXPECT_EQ(NetLog::TYPE_CANCELLED, entries[0].type);
  38   EXPECT_EQ(NetLog::SOURCE_NONE, entries[0].source.type);
  39   EXPECT_NE(NetLog::Source::kInvalidId, entries[0].source.id);
  40   EXPECT_EQ(NetLog::PHASE_NONE, entries[0].phase);
  41   EXPECT_GE(base::TimeTicks::Now(), entries[0].time);
  42   EXPECT_FALSE(entries[0].params);
  43 }
  44
  45 // Check that the correct LogLevel is sent to NetLog Value callbacks.
  46 TEST(NetLogTest, LogLevels) {
  47   CapturingNetLog net_log;
  48   for (int log_level = NetLog::LOG_ALL; log_level < NetLog::LOG_NONE;
  49        ++log_level) {
  50     net_log.SetLogLevel(static_cast<NetLog::LogLevel>(log_level));
  51     EXPECT_EQ(log_level, net_log.GetLogLevel());
  52
  53     net_log.AddGlobalEntry(NetLog::TYPE_SOCKET_ALIVE,
  54                            base::Bind(NetLogLevelCallback));
  55
  56     CapturingNetLog::CapturedEntryList entries;
  57     net_log.GetEntries(&entries);
  58
  59     ASSERT_EQ(1u, entries.size());
  60     EXPECT_EQ(NetLog::TYPE_SOCKET_ALIVE, entries[0].type);
  61     EXPECT_EQ(NetLog::SOURCE_NONE, entries[0].source.type);
  62     EXPECT_NE(NetLog::Source::kInvalidId, entries[0].source.id);
  63     EXPECT_EQ(NetLog::PHASE_NONE, entries[0].phase);
  64     EXPECT_GE(base::TimeTicks::Now(), entries[0].time);
  65
  66     int logged_log_level;
  67     ASSERT_TRUE(entries[0].GetIntegerValue("log_level", &logged_log_level));
  68     EXPECT_EQ(log_level, logged_log_level);
  69
  70     net_log.Clear();
  71   }
  72 }
  73
  74 class CountingObserver : public NetLog::ThreadSafeObserver {
  75  public:
  76   CountingObserver() : count_(0) {}
  77
  78   ~CountingObserver() override {
  79     if (net_log())
  80       net_log()->DeprecatedRemoveObserver(this);
  81   }
  82
  83   void OnAddEntry(const NetLog::Entry& entry) override { ++count_; }
  84
  85   int count() const { return count_; }
  86
  87  private:
  88   int count_;
  89 };
  90
  91 class LoggingObserver : public NetLog::ThreadSafeObserver {
  92  public:
  93   LoggingObserver() {}
  94
  95   ~LoggingObserver() override {
  96     if (net_log())
  97       net_log()->DeprecatedRemoveObserver(this);
  98   }
  99
 100   void OnAddEntry(const NetLog::Entry& entry) override {
 101     base::Value* value = entry.ToValue();
 102     base::DictionaryValue* dict = NULL;
 103     ASSERT_TRUE(value->GetAsDictionary(&dict));
 104     values_.push_back(dict);
 105   }
 106
 107   size_t GetNumValues() const { return values_.size(); }
 108   base::DictionaryValue* GetValue(size_t index) const { return values_[index]; }
 109
 110  private:
 111   ScopedVector<base::DictionaryValue> values_;
 112 };
 113
 114 base::Value* LogLevelToValue(NetLog::LogLevel log_level) {
 115   return new base::FundamentalValue(log_level);
 116 }
 117
 118 void AddEvent(NetLog* net_log) {
 119   net_log->AddGlobalEntry(NetLog::TYPE_CANCELLED, base::Bind(LogLevelToValue));
 120 }
 121
 122 // A thread that waits until an event has been signalled before calling
 123 // RunTestThread.
 124 class NetLogTestThread : public base::SimpleThread {
 125  public:
 126   NetLogTestThread()
 127       : base::SimpleThread("NetLogTest"), net_log_(NULL), start_event_(NULL) {}
 128
 129   // We'll wait for |start_event| to be triggered before calling a subclass's
 130   // subclass's RunTestThread() function.
 131   void Init(NetLog* net_log, base::WaitableEvent* start_event) {
 132     start_event_ = start_event;
 133     net_log_ = net_log;
 134   }
 135
 136   void Run() override {
 137     start_event_->Wait();
 138     RunTestThread();
 139   }
 140
 141   // Subclasses must override this with the code they want to run on their
 142   // thread.
 143   virtual void RunTestThread() = 0;
 144
 145  protected:
 146   NetLog* net_log_;
 147
 148  private:
 149   // Only triggered once all threads have been created, to make it less likely
 150   // each thread completes before the next one starts.
 151   base::WaitableEvent* start_event_;
 152
 153   DISALLOW_COPY_AND_ASSIGN(NetLogTestThread);
 154 };
 155
 156 // A thread that adds a bunch of events to the NetLog.
 157 class AddEventsTestThread : public NetLogTestThread {
 158  public:
 159   AddEventsTestThread() {}
 160   ~AddEventsTestThread() override {}
 161
 162  private:
 163   void RunTestThread() override {
 164     for (int i = 0; i < kEvents; ++i)
 165       AddEvent(net_log_);
 166   }
 167
 168   DISALLOW_COPY_AND_ASSIGN(AddEventsTestThread);
 169 };
 170
 171 // A thread that adds and removes an observer from the NetLog repeatedly.
 172 class AddRemoveObserverTestThread : public NetLogTestThread {
 173  public:
 174   AddRemoveObserverTestThread() {}
 175
 176   ~AddRemoveObserverTestThread() override { EXPECT_TRUE(!observer_.net_log()); }
 177
 178  private:
 179   void RunTestThread() override {
 180     for (int i = 0; i < kEvents; ++i) {
 181       ASSERT_FALSE(observer_.net_log());
 182
 183       net_log_->DeprecatedAddObserver(&observer_, NetLog::LOG_ALL_BUT_BYTES);
 184       ASSERT_EQ(net_log_, observer_.net_log());
 185       ASSERT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer_.log_level());
 186       ASSERT_LE(net_log_->GetLogLevel(), NetLog::LOG_ALL_BUT_BYTES);
 187
 188       net_log_->SetObserverLogLevel(&observer_, NetLog::LOG_ALL);
 189       ASSERT_EQ(net_log_, observer_.net_log());
 190       ASSERT_EQ(NetLog::LOG_ALL, observer_.log_level());
 191       ASSERT_LE(net_log_->GetLogLevel(), NetLog::LOG_ALL);
 192
 193       net_log_->DeprecatedRemoveObserver(&observer_);
 194       ASSERT_TRUE(!observer_.net_log());
 195     }
 196   }
 197
 198   CountingObserver observer_;
 199
 200   DISALLOW_COPY_AND_ASSIGN(AddRemoveObserverTestThread);
 201 };
 202
 203 // Creates |kThreads| threads of type |ThreadType| and then runs them all
 204 // to completion.
 205 template <class ThreadType>
 206 void RunTestThreads(NetLog* net_log) {
 207   ThreadType threads[kThreads];
 208   base::WaitableEvent start_event(true, false);
 209
 210   for (size_t i = 0; i < arraysize(threads); ++i) {
 211     threads[i].Init(net_log, &start_event);
 212     threads[i].Start();
 213   }
 214
 215   start_event.Signal();
 216
 217   for (size_t i = 0; i < arraysize(threads); ++i)
 218     threads[i].Join();
 219 }
 220
 221 // Makes sure that events on multiple threads are dispatched to all observers.
 222 TEST(NetLogTest, NetLogEventThreads) {
 223   NetLog net_log;
 224
 225   // Attach some observers.  Since they're created after |net_log|, they'll
 226   // safely detach themselves on destruction.
 227   CountingObserver observers[3];
 228   for (size_t i = 0; i < arraysize(observers); ++i)
 229     net_log.DeprecatedAddObserver(&observers[i], NetLog::LOG_ALL);
 230
 231   // Run a bunch of threads to completion, each of which will emit events to
 232   // |net_log|.
 233   RunTestThreads<AddEventsTestThread>(&net_log);
 234
 235   // Check that each observer saw the emitted events.
 236   const int kTotalEvents = kThreads * kEvents;
 237   for (size_t i = 0; i < arraysize(observers); ++i)
 238     EXPECT_EQ(kTotalEvents, observers[i].count());
 239 }
 240
 241 // Test adding and removing a single observer.
 242 TEST(NetLogTest, NetLogAddRemoveObserver) {
 243   NetLog net_log;
 244   CountingObserver observer;
 245
 246   AddEvent(&net_log);
 247   EXPECT_EQ(0, observer.count());
 248   EXPECT_EQ(NULL, observer.net_log());
 249   EXPECT_EQ(NetLog::LOG_NONE, net_log.GetLogLevel());
 250
 251   // Add the observer and add an event.
 252   net_log.DeprecatedAddObserver(&observer, NetLog::LOG_ALL_BUT_BYTES);
 253   EXPECT_EQ(&net_log, observer.net_log());
 254   EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer.log_level());
 255   EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, net_log.GetLogLevel());
 256
 257   AddEvent(&net_log);
 258   EXPECT_EQ(1, observer.count());
 259
 260   // Change the observer's logging level and add an event.
 261   net_log.SetObserverLogLevel(&observer, NetLog::LOG_ALL);
 262   EXPECT_EQ(&net_log, observer.net_log());
 263   EXPECT_EQ(NetLog::LOG_ALL, observer.log_level());
 264   EXPECT_EQ(NetLog::LOG_ALL, net_log.GetLogLevel());
 265
 266   AddEvent(&net_log);
 267   EXPECT_EQ(2, observer.count());
 268
 269   // Remove observer and add an event.
 270   net_log.DeprecatedRemoveObserver(&observer);
 271   EXPECT_EQ(NULL, observer.net_log());
 272   EXPECT_EQ(NetLog::LOG_NONE, net_log.GetLogLevel());
 273
 274   AddEvent(&net_log);
 275   EXPECT_EQ(2, observer.count());
 276
 277   // Add the observer a final time, and add an event.
 278   net_log.DeprecatedAddObserver(&observer, NetLog::LOG_ALL);
 279   EXPECT_EQ(&net_log, observer.net_log());
 280   EXPECT_EQ(NetLog::LOG_ALL, observer.log_level());
 281   EXPECT_EQ(NetLog::LOG_ALL, net_log.GetLogLevel());
 282
 283   AddEvent(&net_log);
 284   EXPECT_EQ(3, observer.count());
 285 }
 286
 287 // Test adding and removing two observers at different log levels.
 288 TEST(NetLogTest, NetLogTwoObservers) {
 289   NetLog net_log;
 290   LoggingObserver observer[2];
 291
 292   // Add first observer.
 293   net_log.DeprecatedAddObserver(&observer[0], NetLog::LOG_ALL_BUT_BYTES);
 294   EXPECT_EQ(&net_log, observer[0].net_log());
 295   EXPECT_EQ(NULL, observer[1].net_log());
 296   EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer[0].log_level());
 297   EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, net_log.GetLogLevel());
 298
 299   // Add second observer observer.
 300   net_log.DeprecatedAddObserver(&observer[1], NetLog::LOG_ALL);
 301   EXPECT_EQ(&net_log, observer[0].net_log());
 302   EXPECT_EQ(&net_log, observer[1].net_log());
 303   EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer[0].log_level());
 304   EXPECT_EQ(NetLog::LOG_ALL, observer[1].log_level());
 305   EXPECT_EQ(NetLog::LOG_ALL, net_log.GetLogLevel());
 306
 307   // Add event and make sure both observers receive it at their respective log
 308   // levels.
 309   int param;
 310   AddEvent(&net_log);
 311   ASSERT_EQ(1U, observer[0].GetNumValues());
 312   ASSERT_TRUE(observer[0].GetValue(0)->GetInteger("params", &param));
 313   EXPECT_EQ(observer[0].log_level(), param);
 314   ASSERT_EQ(1U, observer[1].GetNumValues());
 315   ASSERT_TRUE(observer[1].GetValue(0)->GetInteger("params", &param));
 316   EXPECT_EQ(observer[1].log_level(), param);
 317
 318   // Remove second observer.
 319   net_log.DeprecatedRemoveObserver(&observer[1]);
 320   EXPECT_EQ(&net_log, observer[0].net_log());
 321   EXPECT_EQ(NULL, observer[1].net_log());
 322   EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer[0].log_level());
 323   EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, net_log.GetLogLevel());
 324
 325   // Add event and make sure only second observer gets it.
 326   AddEvent(&net_log);
 327   EXPECT_EQ(2U, observer[0].GetNumValues());
 328   EXPECT_EQ(1U, observer[1].GetNumValues());
 329
 330   // Remove first observer.
 331   net_log.DeprecatedRemoveObserver(&observer[0]);
 332   EXPECT_EQ(NULL, observer[0].net_log());
 333   EXPECT_EQ(NULL, observer[1].net_log());
 334   EXPECT_EQ(NetLog::LOG_NONE, net_log.GetLogLevel());
 335
 336   // Add event and make sure neither observer gets it.
 337   AddEvent(&net_log);
 338   EXPECT_EQ(2U, observer[0].GetNumValues());
 339   EXPECT_EQ(1U, observer[1].GetNumValues());
 340 }
 341
 342 // Makes sure that adding and removing observers simultaneously on different
 343 // threads works.
 344 TEST(NetLogTest, NetLogAddRemoveObserverThreads) {
 345   NetLog net_log;
 346
 347   // Run a bunch of threads to completion, each of which will repeatedly add
 348   // and remove an observer, and set its logging level.
 349   RunTestThreads<AddRemoveObserverTestThread>(&net_log);
 350 }
 351
 352 }  // namespace
 353
 354 }  // namespace net