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 #include "base/test/sequenced_task_runner_test_template.h" 6 7 #include <ostream> 8 9 #include "base/location.h" 10 11 namespace base { 12 13 namespace internal { 14 15 TaskEvent::TaskEvent(int i, Type type) 16 : i(i), type(type) { 17 } 18 19 SequencedTaskTracker::SequencedTaskTracker() 20 : next_post_i_(0), 21 task_end_count_(0), 22 task_end_cv_(&lock_) { 23 } 24 25 void SequencedTaskTracker::PostWrappedNonNestableTask( 26 const scoped_refptr<SequencedTaskRunner>& task_runner, 27 const Closure& task) { 28 AutoLock event_lock(lock_); 29 const int post_i = next_post_i_++; 30 Closure wrapped_task = Bind(&SequencedTaskTracker::RunTask, this, 31 task, post_i); 32 task_runner->PostNonNestableTask(FROM_HERE, wrapped_task); 33 TaskPosted(post_i); 34 } 35 36 void SequencedTaskTracker::PostWrappedNestableTask( 37 const scoped_refptr<SequencedTaskRunner>& task_runner, 38 const Closure& task) { 39 AutoLock event_lock(lock_); 40 const int post_i = next_post_i_++; 41 Closure wrapped_task = Bind(&SequencedTaskTracker::RunTask, this, 42 task, post_i); 43 task_runner->PostTask(FROM_HERE, wrapped_task); 44 TaskPosted(post_i); 45 } 46 47 void SequencedTaskTracker::PostWrappedDelayedNonNestableTask( 48 const scoped_refptr<SequencedTaskRunner>& task_runner, 49 const Closure& task, 50 TimeDelta delay) { 51 AutoLock event_lock(lock_); 52 const int post_i = next_post_i_++; 53 Closure wrapped_task = Bind(&SequencedTaskTracker::RunTask, this, 54 task, post_i); 55 task_runner->PostNonNestableDelayedTask(FROM_HERE, wrapped_task, delay); 56 TaskPosted(post_i); 57 } 58 59 void SequencedTaskTracker::PostNonNestableTasks( 60 const scoped_refptr<SequencedTaskRunner>& task_runner, 61 int task_count) { 62 for (int i = 0; i < task_count; ++i) { 63 PostWrappedNonNestableTask(task_runner, Closure()); 64 } 65 } 66 67 void SequencedTaskTracker::RunTask(const Closure& task, int task_i) { 68 TaskStarted(task_i); 69 if (!task.is_null()) 70 task.Run(); 71 TaskEnded(task_i); 72 } 73 74 void SequencedTaskTracker::TaskPosted(int i) { 75 // Caller must own |lock_|. 76 events_.push_back(TaskEvent(i, TaskEvent::POST)); 77 } 78 79 void SequencedTaskTracker::TaskStarted(int i) { 80 AutoLock lock(lock_); 81 events_.push_back(TaskEvent(i, TaskEvent::START)); 82 } 83 84 void SequencedTaskTracker::TaskEnded(int i) { 85 AutoLock lock(lock_); 86 events_.push_back(TaskEvent(i, TaskEvent::END)); 87 ++task_end_count_; 88 task_end_cv_.Signal(); 89 } 90 91 const std::vector<TaskEvent>& 92 SequencedTaskTracker::GetTaskEvents() const { 93 return events_; 94 } 95 96 void SequencedTaskTracker::WaitForCompletedTasks(int count) { 97 AutoLock lock(lock_); 98 while (task_end_count_ < count) 99 task_end_cv_.Wait(); 100 } 101 102 SequencedTaskTracker::~SequencedTaskTracker() { 103 } 104 105 void PrintTo(const TaskEvent& event, std::ostream* os) { 106 *os << "(i=" << event.i << ", type="; 107 switch (event.type) { 108 case TaskEvent::POST: *os << "POST"; break; 109 case TaskEvent::START: *os << "START"; break; 110 case TaskEvent::END: *os << "END"; break; 111 } 112 *os << ")"; 113 } 114 115 namespace { 116 117 // Returns the task ordinals for the task event type |type| in the order that 118 // they were recorded. 119 std::vector<int> GetEventTypeOrder(const std::vector<TaskEvent>& events, 120 TaskEvent::Type type) { 121 std::vector<int> tasks; 122 std::vector<TaskEvent>::const_iterator event; 123 for (event = events.begin(); event != events.end(); ++event) { 124 if (event->type == type) 125 tasks.push_back(event->i); 126 } 127 return tasks; 128 } 129 130 // Returns all task events for task |task_i|. 131 std::vector<TaskEvent::Type> GetEventsForTask( 132 const std::vector<TaskEvent>& events, 133 int task_i) { 134 std::vector<TaskEvent::Type> task_event_orders; 135 std::vector<TaskEvent>::const_iterator event; 136 for (event = events.begin(); event != events.end(); ++event) { 137 if (event->i == task_i) 138 task_event_orders.push_back(event->type); 139 } 140 return task_event_orders; 141 } 142 143 // Checks that the task events for each task in |events| occur in the order 144 // {POST, START, END}, and that there is only one instance of each event type 145 // per task. 146 ::testing::AssertionResult CheckEventOrdersForEachTask( 147 const std::vector<TaskEvent>& events, 148 int task_count) { 149 std::vector<TaskEvent::Type> expected_order; 150 expected_order.push_back(TaskEvent::POST); 151 expected_order.push_back(TaskEvent::START); 152 expected_order.push_back(TaskEvent::END); 153 154 // This is O(n^2), but it runs fast enough currently so is not worth 155 // optimizing. 156 for (int i = 0; i < task_count; ++i) { 157 const std::vector<TaskEvent::Type> task_events = 158 GetEventsForTask(events, i); 159 if (task_events != expected_order) { 160 return ::testing::AssertionFailure() 161 << "Events for task " << i << " are out of order; expected: " 162 << ::testing::PrintToString(expected_order) << "; actual: " 163 << ::testing::PrintToString(task_events); 164 } 165 } 166 return ::testing::AssertionSuccess(); 167 } 168 169 // Checks that no two tasks were running at the same time. I.e. the only 170 // events allowed between the START and END of a task are the POSTs of other 171 // tasks. 172 ::testing::AssertionResult CheckNoTaskRunsOverlap( 173 const std::vector<TaskEvent>& events) { 174 // If > -1, we're currently inside a START, END pair. 175 int current_task_i = -1; 176 177 std::vector<TaskEvent>::const_iterator event; 178 for (event = events.begin(); event != events.end(); ++event) { 179 bool spurious_event_found = false; 180 181 if (current_task_i == -1) { // Not inside a START, END pair. 182 switch (event->type) { 183 case TaskEvent::POST: 184 break; 185 case TaskEvent::START: 186 current_task_i = event->i; 187 break; 188 case TaskEvent::END: 189 spurious_event_found = true; 190 break; 191 } 192 193 } else { // Inside a START, END pair. 194 bool interleaved_task_detected = false; 195 196 switch (event->type) { 197 case TaskEvent::POST: 198 if (event->i == current_task_i) 199 spurious_event_found = true; 200 break; 201 case TaskEvent::START: 202 interleaved_task_detected = true; 203 break; 204 case TaskEvent::END: 205 if (event->i != current_task_i) 206 interleaved_task_detected = true; 207 else 208 current_task_i = -1; 209 break; 210 } 211 212 if (interleaved_task_detected) { 213 return ::testing::AssertionFailure() 214 << "Found event " << ::testing::PrintToString(*event) 215 << " between START and END events for task " << current_task_i 216 << "; event dump: " << ::testing::PrintToString(events); 217 } 218 } 219 220 if (spurious_event_found) { 221 const int event_i = event - events.begin(); 222 return ::testing::AssertionFailure() 223 << "Spurious event " << ::testing::PrintToString(*event) 224 << " at position " << event_i << "; event dump: " 225 << ::testing::PrintToString(events); 226 } 227 } 228 229 return ::testing::AssertionSuccess(); 230 } 231 232 } // namespace 233 234 ::testing::AssertionResult CheckNonNestableInvariants( 235 const std::vector<TaskEvent>& events, 236 int task_count) { 237 const std::vector<int> post_order = 238 GetEventTypeOrder(events, TaskEvent::POST); 239 const std::vector<int> start_order = 240 GetEventTypeOrder(events, TaskEvent::START); 241 const std::vector<int> end_order = 242 GetEventTypeOrder(events, TaskEvent::END); 243 244 if (start_order != post_order) { 245 return ::testing::AssertionFailure() 246 << "Expected START order (which equals actual POST order): \n" 247 << ::testing::PrintToString(post_order) 248 << "\n Actual START order:\n" 249 << ::testing::PrintToString(start_order); 250 } 251 252 if (end_order != post_order) { 253 return ::testing::AssertionFailure() 254 << "Expected END order (which equals actual POST order): \n" 255 << ::testing::PrintToString(post_order) 256 << "\n Actual END order:\n" 257 << ::testing::PrintToString(end_order); 258 } 259 260 const ::testing::AssertionResult result = 261 CheckEventOrdersForEachTask(events, task_count); 262 if (!result) 263 return result; 264 265 return CheckNoTaskRunsOverlap(events); 266 } 267 268 } // namespace internal 269 270 } // namespace base 271
