net/base/net_log_unittest.h

   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 #ifndef NET_BASE_NET_LOG_UNITTEST_H_
   6 #define NET_BASE_NET_LOG_UNITTEST_H_
   7
   8 #include <cstddef>
   9
  10 #include "net/base/capturing_net_log.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace net {
  14
  15 // Create a timestamp with internal value of |t| milliseconds from the epoch.
  16 inline base::TimeTicks MakeTime(int t) {
  17   base::TimeTicks ticks;  // initialized to 0.
  18   ticks += base::TimeDelta::FromMilliseconds(t);
  19   return ticks;
  20 }
  21
  22 inline ::testing::AssertionResult LogContainsEventHelper(
  23     const CapturingNetLog::CapturedEntryList& entries,
  24     int i,  // Negative indices are reverse indices.
  25     const base::TimeTicks& expected_time,
  26     bool check_time,
  27     NetLog::EventType expected_event,
  28     NetLog::EventPhase expected_phase) {
  29   // Negative indices are reverse indices.
  30   size_t j = (i < 0) ?
  31       static_cast<size_t>(static_cast<int>(entries.size()) + i) :
  32       static_cast<size_t>(i);
  33   if (j >= entries.size())
  34     return ::testing::AssertionFailure() << j << " is out of bounds.";
  35   const CapturingNetLog::CapturedEntry& entry = entries[j];
  36   if (expected_event != entry.type) {
  37     return ::testing::AssertionFailure()
  38         << "Actual event: " << NetLog::EventTypeToString(entry.type)
  39         << ". Expected event: " << NetLog::EventTypeToString(expected_event)
  40         << ".";
  41   }
  42   if (expected_phase != entry.phase) {
  43     return ::testing::AssertionFailure()
  44         << "Actual phase: " << entry.phase
  45         << ". Expected phase: " << expected_phase << ".";
  46   }
  47   if (check_time) {
  48     if (expected_time != entry.time) {
  49       return ::testing::AssertionFailure()
  50           << "Actual time: " << entry.time.ToInternalValue()
  51           << ". Expected time: " << expected_time.ToInternalValue()
  52           << ".";
  53     }
  54   }
  55   return ::testing::AssertionSuccess();
  56 }
  57
  58 inline ::testing::AssertionResult LogContainsEventAtTime(
  59     const CapturingNetLog::CapturedEntryList& log,
  60     int i,  // Negative indices are reverse indices.
  61     const base::TimeTicks& expected_time,
  62     NetLog::EventType expected_event,
  63     NetLog::EventPhase expected_phase) {
  64   return LogContainsEventHelper(log, i, expected_time, true,
  65                                 expected_event, expected_phase);
  66 }
  67
  68 // Version without timestamp.
  69 inline ::testing::AssertionResult LogContainsEvent(
  70     const CapturingNetLog::CapturedEntryList& log,
  71     int i,  // Negative indices are reverse indices.
  72     NetLog::EventType expected_event,
  73     NetLog::EventPhase expected_phase) {
  74   return LogContainsEventHelper(log, i, base::TimeTicks(), false,
  75                                 expected_event, expected_phase);
  76 }
  77
  78 // Version for PHASE_BEGIN (and no timestamp).
  79 inline ::testing::AssertionResult LogContainsBeginEvent(
  80     const CapturingNetLog::CapturedEntryList& log,
  81     int i,  // Negative indices are reverse indices.
  82     NetLog::EventType expected_event) {
  83   return LogContainsEvent(log, i, expected_event, NetLog::PHASE_BEGIN);
  84 }
  85
  86 // Version for PHASE_END (and no timestamp).
  87 inline ::testing::AssertionResult LogContainsEndEvent(
  88     const CapturingNetLog::CapturedEntryList& log,
  89     int i,  // Negative indices are reverse indices.
  90     NetLog::EventType expected_event) {
  91   return LogContainsEvent(log, i, expected_event, NetLog::PHASE_END);
  92 }
  93
  94 inline ::testing::AssertionResult LogContainsEntryWithType(
  95     const CapturingNetLog::CapturedEntryList& entries,
  96     int i, // Negative indices are reverse indices.
  97     NetLog::EventType type) {
  98   // Negative indices are reverse indices.
  99   size_t j = (i < 0) ?
 100       static_cast<size_t>(static_cast<int>(entries.size()) + i) :
 101       static_cast<size_t>(i);
 102   if (j >= entries.size())
 103     return ::testing::AssertionFailure() << j << " is out of bounds.";
 104   const CapturingNetLog::CapturedEntry& entry = entries[j];
 105   if (entry.type != type)
 106     return ::testing::AssertionFailure() << "Type does not match.";
 107   return ::testing::AssertionSuccess();
 108 }
 109
 110 // Check if the log contains any entry of the given type at |min_index| or
 111 // after.
 112 inline ::testing::AssertionResult LogContainsEntryWithTypeAfter(
 113     const CapturingNetLog::CapturedEntryList& entries,
 114     int min_index, // Negative indices are reverse indices.
 115     NetLog::EventType type) {
 116   // Negative indices are reverse indices.
 117   size_t real_index = (min_index < 0) ?
 118       static_cast<size_t>(static_cast<int>(entries.size()) + min_index) :
 119       static_cast<size_t>(min_index);
 120   for (size_t i = real_index; i < entries.size(); ++i) {
 121     const CapturingNetLog::CapturedEntry& entry = entries[i];
 122     if (entry.type == type)
 123       return ::testing::AssertionSuccess();
 124   }
 125   return ::testing::AssertionFailure();
 126 }
 127
 128 // Expect that the log contains an event, but don't care about where
 129 // as long as the first index where it is found is at least |min_index|.
 130 // Returns the position where the event was found.
 131 inline size_t ExpectLogContainsSomewhere(
 132     const CapturingNetLog::CapturedEntryList& entries,
 133     size_t min_index,
 134     NetLog::EventType expected_event,
 135     NetLog::EventPhase expected_phase) {
 136   size_t i = 0;
 137   for (; i < entries.size(); ++i) {
 138     const CapturingNetLog::CapturedEntry& entry = entries[i];
 139     if (entry.type == expected_event &&
 140         entry.phase == expected_phase)
 141       break;
 142   }
 143   EXPECT_LT(i, entries.size());
 144   EXPECT_GE(i, min_index);
 145   return i;
 146 }
 147
 148 // Expect that the log contains an event, but don't care about where
 149 // as long as one index where it is found is at least |min_index|.
 150 // Returns the first such position where the event was found.
 151 inline size_t ExpectLogContainsSomewhereAfter(
 152     const CapturingNetLog::CapturedEntryList& entries,
 153     size_t min_index,
 154     NetLog::EventType expected_event,
 155     NetLog::EventPhase expected_phase) {
 156   size_t i = min_index;
 157   for (; i < entries.size(); ++i) {
 158     const CapturingNetLog::CapturedEntry& entry = entries[i];
 159     if (entry.type == expected_event &&
 160         entry.phase == expected_phase)
 161       break;
 162   }
 163   EXPECT_LT(i, entries.size());
 164   return i;
 165 }
 166
 167 }  // namespace net
 168
 169 #endif  // NET_BASE_NET_LOG_UNITTEST_H_