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_ 170
