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