clang-format runtime/vm

runtime/vm/message_handler_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/message_handler.h"
 #include "vm/port.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
@@ skipping 21 matching lines @@
 
 class TestMessageHandler : public MessageHandler {
  public:
   TestMessageHandler()
       : port_buffer_(NULL),
         port_buffer_size_(0),
         notify_count_(0),
         message_count_(0),
         start_called_(false),
         end_called_(false),
-        results_(NULL) {
-  }
+        results_(NULL) {}
 
-  ~TestMessageHandler() {
-    delete[] port_buffer_;
-  }
+  ~TestMessageHandler() { delete[] port_buffer_; }
 
-  void MessageNotify(Message::Priority priority) {
-    notify_count_++;
-  }
+  void MessageNotify(Message::Priority priority) { notify_count_++; }
 
   MessageStatus HandleMessage(Message* message) {
     // For testing purposes, keep a list of the ports
     // for all messages we receive.
     AddPortToBuffer(message->dest_port());
     delete message;
     message_count_++;
     MessageStatus status = kOK;
     if (results_ != NULL) {
       status = results_[0];
@@ skipping 179 matching lines @@
   EXPECT_EQ(port2, ports[0]);
   EXPECT_EQ(port3, ports[1]);
   EXPECT_EQ(port1, ports[2]);
   PortMap::ClosePorts(&handler);
 }
 
 
 UNIT_TEST_CASE(MessageHandler_HandleNextMessage_ProcessOOBAfterError) {
   TestMessageHandler handler;
   MessageHandler::MessageStatus results[] = {
-    MessageHandler::kError,     // oob_message1
-    MessageHandler::kOK,        // oob_message2
-    MessageHandler::kOK,        // unused
+      MessageHandler::kError,  // oob_message1
+      MessageHandler::kOK,     // oob_message2
+      MessageHandler::kOK,     // unused
   };
   handler.set_results(results);
   MessageHandlerTestPeer handler_peer(&handler);
   Dart_Port port1 = PortMap::CreatePort(&handler);
   Dart_Port port2 = PortMap::CreatePort(&handler);
   Dart_Port port3 = PortMap::CreatePort(&handler);
   Message* message1 = new Message(port1, NULL, 0, Message::kNormalPriority);
   handler_peer.PostMessage(message1);
   Message* oob_message1 = new Message(port2, NULL, 0, Message::kOOBPriority);
   handler_peer.PostMessage(oob_message1);
   Message* oob_message2 = new Message(port3, NULL, 0, Message::kOOBPriority);
   handler_peer.PostMessage(oob_message2);
 
   // When we get an error, we continue processing oob messages but
   // stop handling normal messages.
   EXPECT_EQ(MessageHandler::kError, handler.HandleNextMessage());
   EXPECT_EQ(2, handler.message_count());
   Dart_Port* ports = handler.port_buffer();
   EXPECT_EQ(port2, ports[0]);  // oob_message1, error
   EXPECT_EQ(port3, ports[1]);  // oob_message2, ok
   handler_peer.CloseAllPorts();
 }
 
 
 UNIT_TEST_CASE(MessageHandler_HandleNextMessage_Shutdown) {
   TestMessageHandler handler;
   MessageHandler::MessageStatus results[] = {
-    MessageHandler::kOK,        // oob_message1
-    MessageHandler::kShutdown,  // oob_message2
-    MessageHandler::kOK,        // unused
-    MessageHandler::kOK,        // unused
+      MessageHandler::kOK,        // oob_message1
+      MessageHandler::kShutdown,  // oob_message2
+      MessageHandler::kOK,        // unused
+      MessageHandler::kOK,        // unused
   };
   handler.set_results(results);
   MessageHandlerTestPeer handler_peer(&handler);
   Dart_Port port1 = PortMap::CreatePort(&handler);
   Dart_Port port2 = PortMap::CreatePort(&handler);
   Dart_Port port3 = PortMap::CreatePort(&handler);
   Dart_Port port4 = PortMap::CreatePort(&handler);
   Message* message1 = new Message(port1, NULL, 0, Message::kNormalPriority);
   handler_peer.PostMessage(message1);
   Message* oob_message1 = new Message(port2, NULL, 0, Message::kOOBPriority);
@@ skipping 66 matching lines @@
 UNIT_TEST_CASE(MessageHandler_Run) {
   ThreadPool pool;
   TestMessageHandler handler;
   MessageHandlerTestPeer handler_peer(&handler);
   int sleep = 0;
   const int kMaxSleep = 20 * 1000;  // 20 seconds.
 
   EXPECT(!handler.HasLivePorts());
   handler_peer.increment_live_ports();
 
-  handler.Run(&pool,
-              TestStartFunction,
-              TestEndFunction,
+  handler.Run(&pool, TestStartFunction, TestEndFunction,
               reinterpret_cast<uword>(&handler));
   Dart_Port port = PortMap::CreatePort(&handler);
   Message* message = new Message(port, NULL, 0, Message::kNormalPriority);
   handler_peer.PostMessage(message);
 
   // Wait for the first message to be handled.
   while (sleep < kMaxSleep && handler.message_count() < 1) {
     OS::Sleep(10);
     sleep += 10;
   }
@@ skipping 24 matching lines @@
   EXPECT_EQ(port, handler_ports[0]);
   for (int i = 1; i < 11; i++) {
     EXPECT_EQ(ports[i - 1], handler_ports[i]);
   }
   handler_peer.decrement_live_ports();
   EXPECT(!handler.HasLivePorts());
   PortMap::ClosePorts(&handler);
 }
 
 }  // namespace dart