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 14 namespace net { 15 16 // Create a timestamp with internal value of |t| milliseconds from the epoch. 17 inline base::TimeTicks MakeTime(int t) { 18 base::TimeTicks ticks; // initialized to 0. 19 ticks += base::TimeDelta::FromMilliseconds(t); 20 return ticks; 21 } 22 23 inline ::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 59 inline ::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. 70 inline ::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). 80 inline ::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). 88 inline ::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 95 inline ::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. 115 inline 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. 135 inline 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