VM: Re-format to use at most one newline between functions

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 11 matching lines @@
 
   MessageQueue* queue() const { return handler_->queue_; }
   MessageQueue* oob_queue() const { return handler_->oob_queue_; }
 
  private:
   MessageHandler* handler_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageHandlerTestPeer);
 };
 
-
 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) {}
@@ skipping 56 matching lines @@
   int port_buffer_size_;
   int notify_count_;
   int message_count_;
   bool start_called_;
   bool end_called_;
   MessageStatus* results_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMessageHandler);
 };
 
-
 MessageHandler::MessageStatus TestStartFunction(uword data) {
   return (reinterpret_cast<TestMessageHandler*>(data))->Start();
 }
 
-
 void TestEndFunction(uword data) {
   return (reinterpret_cast<TestMessageHandler*>(data))->End();
 }
 
-
 VM_UNIT_TEST_CASE(MessageHandler_PostMessage) {
   TestMessageHandler handler;
   MessageHandlerTestPeer handler_peer(&handler);
   EXPECT_EQ(0, handler.notify_count());
 
   // Post a message.
   Message* message = new Message(1, NULL, 0, Message::kNormalPriority);
   handler_peer.PostMessage(message);
 
   // The notify callback is called.
@@ skipping 10 matching lines @@
 
   // The notify callback is called.
   EXPECT_EQ(2, handler.notify_count());
 
   // The message has been added to the correct queue.
   EXPECT(message == handler_peer.oob_queue()->Dequeue());
   EXPECT(NULL == handler_peer.queue()->Dequeue());
   delete message;
 }
 
-
 VM_UNIT_TEST_CASE(MessageHandler_HasOOBMessages) {
   TestMessageHandler handler;
   MessageHandlerTestPeer handler_peer(&handler);
 
   EXPECT(!handler.HasOOBMessages());
 
   // Post a normal message.
   Message* message = new Message(1, NULL, 0, Message::kNormalPriority);
   handler_peer.PostMessage(message);
   EXPECT(!handler.HasOOBMessages());
@@ skipping 12 matching lines @@
     // OOB message.
     MessageHandler::AcquiredQueues aq(&handler);
     EXPECT(aq.queue()->Length() == 1);
     EXPECT(aq.oob_queue()->Length() == 1);
   }
 
   // Delete all pending messages.
   handler_peer.CloseAllPorts();
 }
 
-
 VM_UNIT_TEST_CASE(MessageHandler_ClosePort) {
   TestMessageHandler handler;
   MessageHandlerTestPeer handler_peer(&handler);
   Message* message1 = new Message(1, NULL, 0, Message::kNormalPriority);
   handler_peer.PostMessage(message1);
   Message* message2 = new Message(2, NULL, 0, Message::kNormalPriority);
   handler_peer.PostMessage(message2);
 
   handler_peer.ClosePort(1);
 
   // Closing the port does not drop the messages from the queue.
   EXPECT(message1 == handler_peer.queue()->Dequeue());
   EXPECT(message2 == handler_peer.queue()->Dequeue());
   delete message1;
   delete message2;
 }
 
-
 VM_UNIT_TEST_CASE(MessageHandler_CloseAllPorts) {
   TestMessageHandler handler;
   MessageHandlerTestPeer handler_peer(&handler);
   Message* message1 = new Message(1, NULL, 0, Message::kNormalPriority);
   handler_peer.PostMessage(message1);
   Message* message2 = new Message(2, NULL, 0, Message::kNormalPriority);
   handler_peer.PostMessage(message2);
 
   handler_peer.CloseAllPorts();
 
   // All messages are dropped from the queue.
   EXPECT(NULL == handler_peer.queue()->Dequeue());
 }
 
-
 VM_UNIT_TEST_CASE(MessageHandler_HandleNextMessage) {
   TestMessageHandler handler;
   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* message2 = new Message(port2, NULL, 0, Message::kNormalPriority);
   handler_peer.PostMessage(message2);
   Message* oob_message2 = new Message(port3, NULL, 0, Message::kOOBPriority);
   handler_peer.PostMessage(oob_message2);
 
   // We handle both oob messages and a single normal message.
   EXPECT_EQ(MessageHandler::kOK, handler.HandleNextMessage());
   EXPECT_EQ(3, handler.message_count());
   Dart_Port* ports = handler.port_buffer();
   EXPECT_EQ(port2, ports[0]);
   EXPECT_EQ(port3, ports[1]);
   EXPECT_EQ(port1, ports[2]);
   PortMap::ClosePorts(&handler);
 }
 
-
 VM_UNIT_TEST_CASE(MessageHandler_HandleNextMessage_ProcessOOBAfterError) {
   TestMessageHandler handler;
   MessageHandler::MessageStatus results[] = {
       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();
 }
 
-
 VM_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
   };
   handler.set_results(results);
   MessageHandlerTestPeer handler_peer(&handler);
@@ skipping 17 matching lines @@
   EXPECT_EQ(port2, ports[0]);  // oob_message1, ok
   EXPECT_EQ(port3, ports[1]);  // oob_message2, shutdown
   {
     // The oob queue has been cleared.  oob_message3 is gone.
     MessageHandler::AcquiredQueues aq(&handler);
     EXPECT(aq.oob_queue()->Length() == 0);
   }
   handler_peer.CloseAllPorts();
 }
 
-
 VM_UNIT_TEST_CASE(MessageHandler_HandleOOBMessages) {
   TestMessageHandler handler;
   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* message2 = new Message(port2, NULL, 0, Message::kNormalPriority);
   handler_peer.PostMessage(message2);
   Message* oob_message1 = new Message(port3, NULL, 0, Message::kOOBPriority);
   handler_peer.PostMessage(oob_message1);
   Message* oob_message2 = new Message(port4, NULL, 0, Message::kOOBPriority);
   handler_peer.PostMessage(oob_message2);
 
   // We handle both oob messages but no normal messages.
   EXPECT_EQ(MessageHandler::kOK, handler.HandleOOBMessages());
   EXPECT_EQ(2, handler.message_count());
   Dart_Port* ports = handler.port_buffer();
   EXPECT_EQ(port3, ports[0]);
   EXPECT_EQ(port4, ports[1]);
   handler_peer.CloseAllPorts();
 }
 
-
 struct ThreadStartInfo {
   MessageHandler* handler;
   Dart_Port* ports;
   int count;
 };
 
-
 static void SendMessages(uword param) {
   ThreadStartInfo* info = reinterpret_cast<ThreadStartInfo*>(param);
   MessageHandler* handler = info->handler;
   MessageHandlerTestPeer handler_peer(handler);
   for (int i = 0; i < info->count; i++) {
     Message* message =
         new Message(info->ports[i], NULL, 0, Message::kNormalPriority);
     handler_peer.PostMessage(message);
   }
 }
 
-
 VM_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();
 
@@ skipping 36 matching lines @@
   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);
   delete[] ports;
 }
 
 }  // namespace dart