OLD | NEW |
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 #include "vm/message_handler.h" | 5 #include "vm/message_handler.h" |
6 #include "vm/port.h" | 6 #include "vm/port.h" |
7 #include "vm/unit_test.h" | 7 #include "vm/unit_test.h" |
8 | 8 |
9 namespace dart { | 9 namespace dart { |
10 | 10 |
(...skipping 11 matching lines...) Expand all Loading... |
22 | 22 |
23 MessageQueue* queue() const { return handler_->queue_; } | 23 MessageQueue* queue() const { return handler_->queue_; } |
24 MessageQueue* oob_queue() const { return handler_->oob_queue_; } | 24 MessageQueue* oob_queue() const { return handler_->oob_queue_; } |
25 | 25 |
26 private: | 26 private: |
27 MessageHandler* handler_; | 27 MessageHandler* handler_; |
28 | 28 |
29 DISALLOW_COPY_AND_ASSIGN(MessageHandlerTestPeer); | 29 DISALLOW_COPY_AND_ASSIGN(MessageHandlerTestPeer); |
30 }; | 30 }; |
31 | 31 |
32 | |
33 class TestMessageHandler : public MessageHandler { | 32 class TestMessageHandler : public MessageHandler { |
34 public: | 33 public: |
35 TestMessageHandler() | 34 TestMessageHandler() |
36 : port_buffer_(NULL), | 35 : port_buffer_(NULL), |
37 port_buffer_size_(0), | 36 port_buffer_size_(0), |
38 notify_count_(0), | 37 notify_count_(0), |
39 message_count_(0), | 38 message_count_(0), |
40 start_called_(false), | 39 start_called_(false), |
41 end_called_(false), | 40 end_called_(false), |
42 results_(NULL) {} | 41 results_(NULL) {} |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
99 int port_buffer_size_; | 98 int port_buffer_size_; |
100 int notify_count_; | 99 int notify_count_; |
101 int message_count_; | 100 int message_count_; |
102 bool start_called_; | 101 bool start_called_; |
103 bool end_called_; | 102 bool end_called_; |
104 MessageStatus* results_; | 103 MessageStatus* results_; |
105 | 104 |
106 DISALLOW_COPY_AND_ASSIGN(TestMessageHandler); | 105 DISALLOW_COPY_AND_ASSIGN(TestMessageHandler); |
107 }; | 106 }; |
108 | 107 |
109 | |
110 MessageHandler::MessageStatus TestStartFunction(uword data) { | 108 MessageHandler::MessageStatus TestStartFunction(uword data) { |
111 return (reinterpret_cast<TestMessageHandler*>(data))->Start(); | 109 return (reinterpret_cast<TestMessageHandler*>(data))->Start(); |
112 } | 110 } |
113 | 111 |
114 | |
115 void TestEndFunction(uword data) { | 112 void TestEndFunction(uword data) { |
116 return (reinterpret_cast<TestMessageHandler*>(data))->End(); | 113 return (reinterpret_cast<TestMessageHandler*>(data))->End(); |
117 } | 114 } |
118 | 115 |
119 | |
120 VM_UNIT_TEST_CASE(MessageHandler_PostMessage) { | 116 VM_UNIT_TEST_CASE(MessageHandler_PostMessage) { |
121 TestMessageHandler handler; | 117 TestMessageHandler handler; |
122 MessageHandlerTestPeer handler_peer(&handler); | 118 MessageHandlerTestPeer handler_peer(&handler); |
123 EXPECT_EQ(0, handler.notify_count()); | 119 EXPECT_EQ(0, handler.notify_count()); |
124 | 120 |
125 // Post a message. | 121 // Post a message. |
126 Message* message = new Message(1, NULL, 0, Message::kNormalPriority); | 122 Message* message = new Message(1, NULL, 0, Message::kNormalPriority); |
127 handler_peer.PostMessage(message); | 123 handler_peer.PostMessage(message); |
128 | 124 |
129 // The notify callback is called. | 125 // The notify callback is called. |
(...skipping 10 matching lines...) Expand all Loading... |
140 | 136 |
141 // The notify callback is called. | 137 // The notify callback is called. |
142 EXPECT_EQ(2, handler.notify_count()); | 138 EXPECT_EQ(2, handler.notify_count()); |
143 | 139 |
144 // The message has been added to the correct queue. | 140 // The message has been added to the correct queue. |
145 EXPECT(message == handler_peer.oob_queue()->Dequeue()); | 141 EXPECT(message == handler_peer.oob_queue()->Dequeue()); |
146 EXPECT(NULL == handler_peer.queue()->Dequeue()); | 142 EXPECT(NULL == handler_peer.queue()->Dequeue()); |
147 delete message; | 143 delete message; |
148 } | 144 } |
149 | 145 |
150 | |
151 VM_UNIT_TEST_CASE(MessageHandler_HasOOBMessages) { | 146 VM_UNIT_TEST_CASE(MessageHandler_HasOOBMessages) { |
152 TestMessageHandler handler; | 147 TestMessageHandler handler; |
153 MessageHandlerTestPeer handler_peer(&handler); | 148 MessageHandlerTestPeer handler_peer(&handler); |
154 | 149 |
155 EXPECT(!handler.HasOOBMessages()); | 150 EXPECT(!handler.HasOOBMessages()); |
156 | 151 |
157 // Post a normal message. | 152 // Post a normal message. |
158 Message* message = new Message(1, NULL, 0, Message::kNormalPriority); | 153 Message* message = new Message(1, NULL, 0, Message::kNormalPriority); |
159 handler_peer.PostMessage(message); | 154 handler_peer.PostMessage(message); |
160 EXPECT(!handler.HasOOBMessages()); | 155 EXPECT(!handler.HasOOBMessages()); |
(...skipping 12 matching lines...) Expand all Loading... |
173 // OOB message. | 168 // OOB message. |
174 MessageHandler::AcquiredQueues aq(&handler); | 169 MessageHandler::AcquiredQueues aq(&handler); |
175 EXPECT(aq.queue()->Length() == 1); | 170 EXPECT(aq.queue()->Length() == 1); |
176 EXPECT(aq.oob_queue()->Length() == 1); | 171 EXPECT(aq.oob_queue()->Length() == 1); |
177 } | 172 } |
178 | 173 |
179 // Delete all pending messages. | 174 // Delete all pending messages. |
180 handler_peer.CloseAllPorts(); | 175 handler_peer.CloseAllPorts(); |
181 } | 176 } |
182 | 177 |
183 | |
184 VM_UNIT_TEST_CASE(MessageHandler_ClosePort) { | 178 VM_UNIT_TEST_CASE(MessageHandler_ClosePort) { |
185 TestMessageHandler handler; | 179 TestMessageHandler handler; |
186 MessageHandlerTestPeer handler_peer(&handler); | 180 MessageHandlerTestPeer handler_peer(&handler); |
187 Message* message1 = new Message(1, NULL, 0, Message::kNormalPriority); | 181 Message* message1 = new Message(1, NULL, 0, Message::kNormalPriority); |
188 handler_peer.PostMessage(message1); | 182 handler_peer.PostMessage(message1); |
189 Message* message2 = new Message(2, NULL, 0, Message::kNormalPriority); | 183 Message* message2 = new Message(2, NULL, 0, Message::kNormalPriority); |
190 handler_peer.PostMessage(message2); | 184 handler_peer.PostMessage(message2); |
191 | 185 |
192 handler_peer.ClosePort(1); | 186 handler_peer.ClosePort(1); |
193 | 187 |
194 // Closing the port does not drop the messages from the queue. | 188 // Closing the port does not drop the messages from the queue. |
195 EXPECT(message1 == handler_peer.queue()->Dequeue()); | 189 EXPECT(message1 == handler_peer.queue()->Dequeue()); |
196 EXPECT(message2 == handler_peer.queue()->Dequeue()); | 190 EXPECT(message2 == handler_peer.queue()->Dequeue()); |
197 delete message1; | 191 delete message1; |
198 delete message2; | 192 delete message2; |
199 } | 193 } |
200 | 194 |
201 | |
202 VM_UNIT_TEST_CASE(MessageHandler_CloseAllPorts) { | 195 VM_UNIT_TEST_CASE(MessageHandler_CloseAllPorts) { |
203 TestMessageHandler handler; | 196 TestMessageHandler handler; |
204 MessageHandlerTestPeer handler_peer(&handler); | 197 MessageHandlerTestPeer handler_peer(&handler); |
205 Message* message1 = new Message(1, NULL, 0, Message::kNormalPriority); | 198 Message* message1 = new Message(1, NULL, 0, Message::kNormalPriority); |
206 handler_peer.PostMessage(message1); | 199 handler_peer.PostMessage(message1); |
207 Message* message2 = new Message(2, NULL, 0, Message::kNormalPriority); | 200 Message* message2 = new Message(2, NULL, 0, Message::kNormalPriority); |
208 handler_peer.PostMessage(message2); | 201 handler_peer.PostMessage(message2); |
209 | 202 |
210 handler_peer.CloseAllPorts(); | 203 handler_peer.CloseAllPorts(); |
211 | 204 |
212 // All messages are dropped from the queue. | 205 // All messages are dropped from the queue. |
213 EXPECT(NULL == handler_peer.queue()->Dequeue()); | 206 EXPECT(NULL == handler_peer.queue()->Dequeue()); |
214 } | 207 } |
215 | 208 |
216 | |
217 VM_UNIT_TEST_CASE(MessageHandler_HandleNextMessage) { | 209 VM_UNIT_TEST_CASE(MessageHandler_HandleNextMessage) { |
218 TestMessageHandler handler; | 210 TestMessageHandler handler; |
219 MessageHandlerTestPeer handler_peer(&handler); | 211 MessageHandlerTestPeer handler_peer(&handler); |
220 Dart_Port port1 = PortMap::CreatePort(&handler); | 212 Dart_Port port1 = PortMap::CreatePort(&handler); |
221 Dart_Port port2 = PortMap::CreatePort(&handler); | 213 Dart_Port port2 = PortMap::CreatePort(&handler); |
222 Dart_Port port3 = PortMap::CreatePort(&handler); | 214 Dart_Port port3 = PortMap::CreatePort(&handler); |
223 Message* message1 = new Message(port1, NULL, 0, Message::kNormalPriority); | 215 Message* message1 = new Message(port1, NULL, 0, Message::kNormalPriority); |
224 handler_peer.PostMessage(message1); | 216 handler_peer.PostMessage(message1); |
225 Message* oob_message1 = new Message(port2, NULL, 0, Message::kOOBPriority); | 217 Message* oob_message1 = new Message(port2, NULL, 0, Message::kOOBPriority); |
226 handler_peer.PostMessage(oob_message1); | 218 handler_peer.PostMessage(oob_message1); |
227 Message* message2 = new Message(port2, NULL, 0, Message::kNormalPriority); | 219 Message* message2 = new Message(port2, NULL, 0, Message::kNormalPriority); |
228 handler_peer.PostMessage(message2); | 220 handler_peer.PostMessage(message2); |
229 Message* oob_message2 = new Message(port3, NULL, 0, Message::kOOBPriority); | 221 Message* oob_message2 = new Message(port3, NULL, 0, Message::kOOBPriority); |
230 handler_peer.PostMessage(oob_message2); | 222 handler_peer.PostMessage(oob_message2); |
231 | 223 |
232 // We handle both oob messages and a single normal message. | 224 // We handle both oob messages and a single normal message. |
233 EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage()); | 225 EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage()); |
234 EXPECT_EQ(3, handler.message_count()); | 226 EXPECT_EQ(3, handler.message_count()); |
235 Dart_Port* ports = handler.port_buffer(); | 227 Dart_Port* ports = handler.port_buffer(); |
236 EXPECT_EQ(port2, ports[0]); | 228 EXPECT_EQ(port2, ports[0]); |
237 EXPECT_EQ(port3, ports[1]); | 229 EXPECT_EQ(port3, ports[1]); |
238 EXPECT_EQ(port1, ports[2]); | 230 EXPECT_EQ(port1, ports[2]); |
239 PortMap::ClosePorts(&handler); | 231 PortMap::ClosePorts(&handler); |
240 } | 232 } |
241 | 233 |
242 | |
243 VM_UNIT_TEST_CASE(MessageHandler_HandleNextMessage_ProcessOOBAfterError) { | 234 VM_UNIT_TEST_CASE(MessageHandler_HandleNextMessage_ProcessOOBAfterError) { |
244 TestMessageHandler handler; | 235 TestMessageHandler handler; |
245 MessageHandler::MessageStatus results[] = { | 236 MessageHandler::MessageStatus results[] = { |
246 MessageHandler::kError, // oob_message1 | 237 MessageHandler::kError, // oob_message1 |
247 MessageHandler::kOK, // oob_message2 | 238 MessageHandler::kOK, // oob_message2 |
248 MessageHandler::kOK, // unused | 239 MessageHandler::kOK, // unused |
249 }; | 240 }; |
250 handler.set_results(results); | 241 handler.set_results(results); |
251 MessageHandlerTestPeer handler_peer(&handler); | 242 MessageHandlerTestPeer handler_peer(&handler); |
252 Dart_Port port1 = PortMap::CreatePort(&handler); | 243 Dart_Port port1 = PortMap::CreatePort(&handler); |
253 Dart_Port port2 = PortMap::CreatePort(&handler); | 244 Dart_Port port2 = PortMap::CreatePort(&handler); |
254 Dart_Port port3 = PortMap::CreatePort(&handler); | 245 Dart_Port port3 = PortMap::CreatePort(&handler); |
255 Message* message1 = new Message(port1, NULL, 0, Message::kNormalPriority); | 246 Message* message1 = new Message(port1, NULL, 0, Message::kNormalPriority); |
256 handler_peer.PostMessage(message1); | 247 handler_peer.PostMessage(message1); |
257 Message* oob_message1 = new Message(port2, NULL, 0, Message::kOOBPriority); | 248 Message* oob_message1 = new Message(port2, NULL, 0, Message::kOOBPriority); |
258 handler_peer.PostMessage(oob_message1); | 249 handler_peer.PostMessage(oob_message1); |
259 Message* oob_message2 = new Message(port3, NULL, 0, Message::kOOBPriority); | 250 Message* oob_message2 = new Message(port3, NULL, 0, Message::kOOBPriority); |
260 handler_peer.PostMessage(oob_message2); | 251 handler_peer.PostMessage(oob_message2); |
261 | 252 |
262 // When we get an error, we continue processing oob messages but | 253 // When we get an error, we continue processing oob messages but |
263 // stop handling normal messages. | 254 // stop handling normal messages. |
264 EXPECT_EQ(MessageHandler::kError, handler.HandleNextMessage()); | 255 EXPECT_EQ(MessageHandler::kError, handler.HandleNextMessage()); |
265 EXPECT_EQ(2, handler.message_count()); | 256 EXPECT_EQ(2, handler.message_count()); |
266 Dart_Port* ports = handler.port_buffer(); | 257 Dart_Port* ports = handler.port_buffer(); |
267 EXPECT_EQ(port2, ports[0]); // oob_message1, error | 258 EXPECT_EQ(port2, ports[0]); // oob_message1, error |
268 EXPECT_EQ(port3, ports[1]); // oob_message2, ok | 259 EXPECT_EQ(port3, ports[1]); // oob_message2, ok |
269 handler_peer.CloseAllPorts(); | 260 handler_peer.CloseAllPorts(); |
270 } | 261 } |
271 | 262 |
272 | |
273 VM_UNIT_TEST_CASE(MessageHandler_HandleNextMessage_Shutdown) { | 263 VM_UNIT_TEST_CASE(MessageHandler_HandleNextMessage_Shutdown) { |
274 TestMessageHandler handler; | 264 TestMessageHandler handler; |
275 MessageHandler::MessageStatus results[] = { | 265 MessageHandler::MessageStatus results[] = { |
276 MessageHandler::kOK, // oob_message1 | 266 MessageHandler::kOK, // oob_message1 |
277 MessageHandler::kShutdown, // oob_message2 | 267 MessageHandler::kShutdown, // oob_message2 |
278 MessageHandler::kOK, // unused | 268 MessageHandler::kOK, // unused |
279 MessageHandler::kOK, // unused | 269 MessageHandler::kOK, // unused |
280 }; | 270 }; |
281 handler.set_results(results); | 271 handler.set_results(results); |
282 MessageHandlerTestPeer handler_peer(&handler); | 272 MessageHandlerTestPeer handler_peer(&handler); |
(...skipping 17 matching lines...) Expand all Loading... |
300 EXPECT_EQ(port2, ports[0]); // oob_message1, ok | 290 EXPECT_EQ(port2, ports[0]); // oob_message1, ok |
301 EXPECT_EQ(port3, ports[1]); // oob_message2, shutdown | 291 EXPECT_EQ(port3, ports[1]); // oob_message2, shutdown |
302 { | 292 { |
303 // The oob queue has been cleared. oob_message3 is gone. | 293 // The oob queue has been cleared. oob_message3 is gone. |
304 MessageHandler::AcquiredQueues aq(&handler); | 294 MessageHandler::AcquiredQueues aq(&handler); |
305 EXPECT(aq.oob_queue()->Length() == 0); | 295 EXPECT(aq.oob_queue()->Length() == 0); |
306 } | 296 } |
307 handler_peer.CloseAllPorts(); | 297 handler_peer.CloseAllPorts(); |
308 } | 298 } |
309 | 299 |
310 | |
311 VM_UNIT_TEST_CASE(MessageHandler_HandleOOBMessages) { | 300 VM_UNIT_TEST_CASE(MessageHandler_HandleOOBMessages) { |
312 TestMessageHandler handler; | 301 TestMessageHandler handler; |
313 MessageHandlerTestPeer handler_peer(&handler); | 302 MessageHandlerTestPeer handler_peer(&handler); |
314 Dart_Port port1 = PortMap::CreatePort(&handler); | 303 Dart_Port port1 = PortMap::CreatePort(&handler); |
315 Dart_Port port2 = PortMap::CreatePort(&handler); | 304 Dart_Port port2 = PortMap::CreatePort(&handler); |
316 Dart_Port port3 = PortMap::CreatePort(&handler); | 305 Dart_Port port3 = PortMap::CreatePort(&handler); |
317 Dart_Port port4 = PortMap::CreatePort(&handler); | 306 Dart_Port port4 = PortMap::CreatePort(&handler); |
318 Message* message1 = new Message(port1, NULL, 0, Message::kNormalPriority); | 307 Message* message1 = new Message(port1, NULL, 0, Message::kNormalPriority); |
319 handler_peer.PostMessage(message1); | 308 handler_peer.PostMessage(message1); |
320 Message* message2 = new Message(port2, NULL, 0, Message::kNormalPriority); | 309 Message* message2 = new Message(port2, NULL, 0, Message::kNormalPriority); |
321 handler_peer.PostMessage(message2); | 310 handler_peer.PostMessage(message2); |
322 Message* oob_message1 = new Message(port3, NULL, 0, Message::kOOBPriority); | 311 Message* oob_message1 = new Message(port3, NULL, 0, Message::kOOBPriority); |
323 handler_peer.PostMessage(oob_message1); | 312 handler_peer.PostMessage(oob_message1); |
324 Message* oob_message2 = new Message(port4, NULL, 0, Message::kOOBPriority); | 313 Message* oob_message2 = new Message(port4, NULL, 0, Message::kOOBPriority); |
325 handler_peer.PostMessage(oob_message2); | 314 handler_peer.PostMessage(oob_message2); |
326 | 315 |
327 // We handle both oob messages but no normal messages. | 316 // We handle both oob messages but no normal messages. |
328 EXPECT_EQ(MessageHandler::kOK, handler.HandleOOBMessages()); | 317 EXPECT_EQ(MessageHandler::kOK, handler.HandleOOBMessages()); |
329 EXPECT_EQ(2, handler.message_count()); | 318 EXPECT_EQ(2, handler.message_count()); |
330 Dart_Port* ports = handler.port_buffer(); | 319 Dart_Port* ports = handler.port_buffer(); |
331 EXPECT_EQ(port3, ports[0]); | 320 EXPECT_EQ(port3, ports[0]); |
332 EXPECT_EQ(port4, ports[1]); | 321 EXPECT_EQ(port4, ports[1]); |
333 handler_peer.CloseAllPorts(); | 322 handler_peer.CloseAllPorts(); |
334 } | 323 } |
335 | 324 |
336 | |
337 struct ThreadStartInfo { | 325 struct ThreadStartInfo { |
338 MessageHandler* handler; | 326 MessageHandler* handler; |
339 Dart_Port* ports; | 327 Dart_Port* ports; |
340 int count; | 328 int count; |
341 }; | 329 }; |
342 | 330 |
343 | |
344 static void SendMessages(uword param) { | 331 static void SendMessages(uword param) { |
345 ThreadStartInfo* info = reinterpret_cast<ThreadStartInfo*>(param); | 332 ThreadStartInfo* info = reinterpret_cast<ThreadStartInfo*>(param); |
346 MessageHandler* handler = info->handler; | 333 MessageHandler* handler = info->handler; |
347 MessageHandlerTestPeer handler_peer(handler); | 334 MessageHandlerTestPeer handler_peer(handler); |
348 for (int i = 0; i < info->count; i++) { | 335 for (int i = 0; i < info->count; i++) { |
349 Message* message = | 336 Message* message = |
350 new Message(info->ports[i], NULL, 0, Message::kNormalPriority); | 337 new Message(info->ports[i], NULL, 0, Message::kNormalPriority); |
351 handler_peer.PostMessage(message); | 338 handler_peer.PostMessage(message); |
352 } | 339 } |
353 } | 340 } |
354 | 341 |
355 | |
356 VM_UNIT_TEST_CASE(MessageHandler_Run) { | 342 VM_UNIT_TEST_CASE(MessageHandler_Run) { |
357 ThreadPool pool; | 343 ThreadPool pool; |
358 TestMessageHandler handler; | 344 TestMessageHandler handler; |
359 MessageHandlerTestPeer handler_peer(&handler); | 345 MessageHandlerTestPeer handler_peer(&handler); |
360 int sleep = 0; | 346 int sleep = 0; |
361 const int kMaxSleep = 20 * 1000; // 20 seconds. | 347 const int kMaxSleep = 20 * 1000; // 20 seconds. |
362 | 348 |
363 EXPECT(!handler.HasLivePorts()); | 349 EXPECT(!handler.HasLivePorts()); |
364 handler_peer.increment_live_ports(); | 350 handler_peer.increment_live_ports(); |
365 | 351 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
402 for (int i = 1; i < 11; i++) { | 388 for (int i = 1; i < 11; i++) { |
403 EXPECT_EQ(ports[i - 1], handler_ports[i]); | 389 EXPECT_EQ(ports[i - 1], handler_ports[i]); |
404 } | 390 } |
405 handler_peer.decrement_live_ports(); | 391 handler_peer.decrement_live_ports(); |
406 EXPECT(!handler.HasLivePorts()); | 392 EXPECT(!handler.HasLivePorts()); |
407 PortMap::ClosePorts(&handler); | 393 PortMap::ClosePorts(&handler); |
408 delete[] ports; | 394 delete[] ports; |
409 } | 395 } |
410 | 396 |
411 } // namespace dart | 397 } // namespace dart |
OLD | NEW |