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
13namespace net {
14
15// Create a timestamp with internal value of |t| milliseconds from the epoch.
16inline base::TimeTicks MakeTime(int t) {
17  base::TimeTicks ticks;  // initialized to 0.
18  ticks += base::TimeDelta::FromMilliseconds(t);
19  return ticks;
20}
21
22inline ::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
58inline ::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.
69inline ::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).
79inline ::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).
87inline ::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
94inline ::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.
112inline ::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.
131inline 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.
151inline 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_
170