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