| OLD | NEW |
|---|
| (Empty) |
| 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 #include <iosfwd> | |
| 6 #include <sstream> | |
| 7 #include <string> | |
| 8 #include <vector> | |
| 9 | |
| 10 #include "base/basictypes.h" | |
| 11 #include "base/message_loop.h" | |
| 12 #include "base/port.h" | |
| 13 #include "base/threading/platform_thread.h" | |
| 14 #include "build/build_config.h" | |
| 15 #include "chrome/common/deprecated/event_sys-inl.h" | |
| 16 #include "testing/gtest/include/gtest/gtest.h" | |
| 17 | |
| 18 namespace { | |
| 19 | |
| 20 class Pair; | |
| 21 | |
| 22 struct TestEvent { | |
| 23 Pair* source; | |
| 24 enum { | |
| 25 A_CHANGED, B_CHANGED, PAIR_BEING_DELETED, | |
| 26 } what_happened; | |
| 27 int old_value; | |
| 28 }; | |
| 29 | |
| 30 struct TestEventTraits { | |
| 31 typedef TestEvent EventType; | |
| 32 static bool IsChannelShutdownEvent(const TestEvent& event) { | |
| 33 return TestEvent::PAIR_BEING_DELETED == event.what_happened; | |
| 34 } | |
| 35 }; | |
| 36 | |
| 37 class Pair { | |
| 38 public: | |
| 39 typedef EventChannel<TestEventTraits> Channel; | |
| 40 explicit Pair(const std::string& name) : name_(name), a_(0), b_(0) { | |
| 41 TestEvent shutdown = { this, TestEvent::PAIR_BEING_DELETED, 0 }; | |
| 42 event_channel_ = new Channel(shutdown); | |
| 43 } | |
| 44 ~Pair() { | |
| 45 delete event_channel_; | |
| 46 } | |
| 47 void set_a(int n) { | |
| 48 TestEvent event = { this, TestEvent::A_CHANGED, a_ }; | |
| 49 a_ = n; | |
| 50 event_channel_->NotifyListeners(event); | |
| 51 } | |
| 52 void set_b(int n) { | |
| 53 TestEvent event = { this, TestEvent::B_CHANGED, b_ }; | |
| 54 b_ = n; | |
| 55 event_channel_->NotifyListeners(event); | |
| 56 } | |
| 57 int a() const { return a_; } | |
| 58 int b() const { return b_; } | |
| 59 const std::string& name() { return name_; } | |
| 60 Channel* event_channel() const { return event_channel_; } | |
| 61 | |
| 62 protected: | |
| 63 const std::string name_; | |
| 64 int a_; | |
| 65 int b_; | |
| 66 Channel* event_channel_; | |
| 67 }; | |
| 68 | |
| 69 class EventLogger { | |
| 70 public: | |
| 71 explicit EventLogger(std::ostream* out) : out_(out) { } | |
| 72 ~EventLogger() { | |
| 73 for (Hookups::iterator i = hookups_.begin(); i != hookups_.end(); ++i) | |
| 74 delete *i; | |
| 75 } | |
| 76 | |
| 77 void Hookup(const std::string name, Pair::Channel* channel) { | |
| 78 hookups_.push_back(NewEventListenerHookup(channel, this, | |
| 79 &EventLogger::HandlePairEvent, | |
| 80 name)); | |
| 81 } | |
| 82 | |
| 83 void HandlePairEvent(const std::string& name, const TestEvent& event) { | |
| 84 const char* what_changed = NULL; | |
| 85 int new_value = 0; | |
| 86 Hookups::iterator dead; | |
| 87 switch (event.what_happened) { | |
| 88 case TestEvent::A_CHANGED: | |
| 89 what_changed = "A"; | |
| 90 new_value = event.source->a(); | |
| 91 break; | |
| 92 case TestEvent::B_CHANGED: | |
| 93 what_changed = "B"; | |
| 94 new_value = event.source->b(); | |
| 95 break; | |
| 96 case TestEvent::PAIR_BEING_DELETED: | |
| 97 *out_ << name << " heard " << event.source->name() << " being deleted." | |
| 98 << std::endl; | |
| 99 return; | |
| 100 default: | |
| 101 FAIL() << "Bad event.what_happened: " << event.what_happened; | |
| 102 break; | |
| 103 } | |
| 104 *out_ << name << " heard " << event.source->name() << "'s " << what_changed | |
| 105 << " change from " << event.old_value | |
| 106 << " to " << new_value << std::endl; | |
| 107 } | |
| 108 | |
| 109 typedef std::vector<EventListenerHookup*> Hookups; | |
| 110 Hookups hookups_; | |
| 111 std::ostream* out_; | |
| 112 }; | |
| 113 | |
| 114 const char golden_result[] = "Larry heard Sally's B change from 0 to 2\n" | |
| 115 "Larry heard Sally's A change from 1 to 3\n" | |
| 116 "Lewis heard Sam's B change from 0 to 5\n" | |
| 117 "Larry heard Sally's A change from 3 to 6\n" | |
| 118 "Larry heard Sally being deleted.\n"; | |
| 119 | |
| 120 TEST(EventSys, Basic) { | |
| 121 Pair sally("Sally"), sam("Sam"); | |
| 122 sally.set_a(1); | |
| 123 std::stringstream log; | |
| 124 EventLogger logger(&log); | |
| 125 logger.Hookup("Larry", sally.event_channel()); | |
| 126 sally.set_b(2); | |
| 127 sally.set_a(3); | |
| 128 sam.set_a(4); | |
| 129 logger.Hookup("Lewis", sam.event_channel()); | |
| 130 sam.set_b(5); | |
| 131 sally.set_a(6); | |
| 132 // Test that disconnect within callback doesn't deadlock. | |
| 133 TestEvent event = {&sally, TestEvent::PAIR_BEING_DELETED, 0 }; | |
| 134 sally.event_channel()->NotifyListeners(event); | |
| 135 sally.set_a(7); | |
| 136 ASSERT_EQ(log.str(), golden_result); | |
| 137 } | |
| 138 | |
| 139 | |
| 140 // This goes pretty far beyond the normal use pattern, so don't use | |
| 141 // ThreadTester as an example of what to do. | |
| 142 class ThreadTester : public EventListener<TestEvent>, | |
| 143 public base::PlatformThread::Delegate { | |
| 144 public: | |
| 145 explicit ThreadTester(Pair* pair) | |
| 146 : pair_(pair), remove_event_(&remove_event_mutex_), | |
| 147 remove_event_bool_(false), completed_(false) { | |
| 148 pair_->event_channel()->AddListener(this); | |
| 149 } | |
| 150 ~ThreadTester() { | |
| 151 pair_->event_channel()->RemoveListener(this); | |
| 152 for (size_t i = 0; i < threads_.size(); i++) { | |
| 153 base::PlatformThread::Join(threads_[i].thread); | |
| 154 } | |
| 155 } | |
| 156 | |
| 157 struct ThreadInfo { | |
| 158 base::PlatformThreadHandle thread; | |
| 159 }; | |
| 160 | |
| 161 struct ThreadArgs { | |
| 162 base::ConditionVariable* thread_running_cond; | |
| 163 base::Lock* thread_running_mutex; | |
| 164 bool thread_running; | |
| 165 }; | |
| 166 | |
| 167 void Go() { | |
| 168 base::Lock thread_running_mutex; | |
| 169 base::ConditionVariable thread_running_cond(&thread_running_mutex); | |
| 170 ThreadArgs args; | |
| 171 ThreadInfo info; | |
| 172 args.thread_running_cond = &(thread_running_cond); | |
| 173 args.thread_running_mutex = &(thread_running_mutex); | |
| 174 args.thread_running = false; | |
| 175 args_ = args; | |
| 176 ASSERT_TRUE(base::PlatformThread::Create(0, this, &info.thread)); | |
| 177 thread_running_mutex.Acquire(); | |
| 178 while ((args_.thread_running) == false) { | |
| 179 thread_running_cond.Wait(); | |
| 180 } | |
| 181 thread_running_mutex.Release(); | |
| 182 threads_.push_back(info); | |
| 183 } | |
| 184 | |
| 185 // PlatformThread::Delegate methods. | |
| 186 virtual void ThreadMain() { | |
| 187 // Make sure each thread gets a current MessageLoop in TLS. | |
| 188 // This test should use chrome threads for testing, but I'll leave it like | |
| 189 // this for the moment since it requires a big chunk of rewriting and I | |
| 190 // want the test passing while I checkpoint my CL. Technically speaking, | |
| 191 // there should be no functional difference. | |
| 192 MessageLoop message_loop; | |
| 193 args_.thread_running_mutex->Acquire(); | |
| 194 args_.thread_running = true; | |
| 195 args_.thread_running_cond->Signal(); | |
| 196 args_.thread_running_mutex->Release(); | |
| 197 | |
| 198 remove_event_mutex_.Acquire(); | |
| 199 while (remove_event_bool_ == false) { | |
| 200 remove_event_.Wait(); | |
| 201 } | |
| 202 remove_event_mutex_.Release(); | |
| 203 | |
| 204 // Normally, you'd just delete the hookup. This is very bad style, but | |
| 205 // necessary for the test. | |
| 206 pair_->event_channel()->RemoveListener(this); | |
| 207 | |
| 208 completed_mutex_.Acquire(); | |
| 209 completed_ = true; | |
| 210 completed_mutex_.Release(); | |
| 211 } | |
| 212 | |
| 213 void HandleEvent(const TestEvent& event) { | |
| 214 remove_event_mutex_.Acquire(); | |
| 215 remove_event_bool_ = true; | |
| 216 remove_event_.Broadcast(); | |
| 217 remove_event_mutex_.Release(); | |
| 218 | |
| 219 base::PlatformThread::YieldCurrentThread(); | |
| 220 | |
| 221 completed_mutex_.Acquire(); | |
| 222 if (completed_) | |
| 223 FAIL() << "A test thread exited too early."; | |
| 224 completed_mutex_.Release(); | |
| 225 } | |
| 226 | |
| 227 Pair* pair_; | |
| 228 base::ConditionVariable remove_event_; | |
| 229 base::Lock remove_event_mutex_; | |
| 230 bool remove_event_bool_; | |
| 231 base::Lock completed_mutex_; | |
| 232 bool completed_; | |
| 233 std::vector<ThreadInfo> threads_; | |
| 234 ThreadArgs args_; | |
| 235 }; | |
| 236 | |
| 237 TEST(EventSys, Multithreaded) { | |
| 238 Pair sally("Sally"); | |
| 239 ThreadTester a(&sally); | |
| 240 for (int i = 0; i < 3; ++i) | |
| 241 a.Go(); | |
| 242 sally.set_b(99); | |
| 243 } | |
| 244 | |
| 245 class HookupDeleter { | |
| 246 public: | |
| 247 void HandleEvent(const TestEvent& event) { | |
| 248 delete hookup_; | |
| 249 hookup_ = NULL; | |
| 250 } | |
| 251 EventListenerHookup* hookup_; | |
| 252 }; | |
| 253 | |
| 254 TEST(EventSys, InHandlerDeletion) { | |
| 255 Pair sally("Sally"); | |
| 256 HookupDeleter deleter; | |
| 257 deleter.hookup_ = NewEventListenerHookup(sally.event_channel(), | |
| 258 &deleter, | |
| 259 &HookupDeleter::HandleEvent); | |
| 260 sally.set_a(1); | |
| 261 ASSERT_TRUE(NULL == deleter.hookup_); | |
| 262 } | |
| 263 | |
| 264 } // namespace | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 7587009:
sync: add DEPS files to subdirs (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src