Changed MessageReader so that it doesn't read from the socket if there are

remoting/protocol/message_decoder_unittest.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
 
 #include "base/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/message_decoder.h"
@@ skipping 11 matching lines @@
   scoped_refptr<net::IOBufferWithSize> encoded_msg;
   encoded_msg = SerializeAndFrameMessage(msg);
   buffer->append(encoded_msg->data(), encoded_msg->size());
 }
 
 // Construct and prepare data in the |output_stream|.
 static void PrepareData(uint8** buffer, int* size) {
   // Contains all encoded messages.
   std::string encoded_data;
 
-  EventMessage msg;
-
   // Then append 10 update sequences to the data.
   for (int i = 0; i < 10; ++i) {
-    Event* event = msg.add_event();
-    event->set_timestamp(i);
-    event->mutable_key()->set_keycode(kTestKey + i);
-    event->mutable_key()->set_pressed((i % 2) != 0);
+    EventMessage msg;
+    msg.set_timestamp(i);
+    msg.mutable_key()->set_keycode(kTestKey + i);
+    msg.mutable_key()->set_pressed((i % 2) != 0);
     AppendMessage(msg, &encoded_data);
-    msg.Clear();
   }
 
   *size = encoded_data.length();
   *buffer = new uint8[*size];
   memcpy(*buffer, encoded_data.c_str(), *size);
 }
 
 void SimulateReadSequence(const int read_sequence[], int sequence_size) {
   // Prepare encoded data for testing.
   int size;
@@ skipping 12 matching lines @@
   std::list<EventMessage*> message_list;
   for (int i = 0; i < size;) {
     // First generate the amount to feed the decoder.
     int read = std::min(size - i, read_sequence[i % sequence_size]);
 
     // And then prepare an IOBuffer for feeding it.
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(read));
     memcpy(buffer->data(), test_data + i, read);
     decoder.AddData(buffer, read);
     while (true) {
-      CompoundBuffer message;
-      if (!decoder.GetNextMessage(&message))
+      scoped_ptr<CompoundBuffer> message(decoder.GetNextMessage());
+      if (!message.get())
         break;
 
       EventMessage* event = new EventMessage();
-      CompoundBufferInputStream stream(&message);
+      CompoundBufferInputStream stream(message.get());
       ASSERT_TRUE(event->ParseFromZeroCopyStream(&stream));
       message_list.push_back(event);
     }
     i += read;
   }
 
   // Then verify the decoded messages.
   EXPECT_EQ(10u, message_list.size());
 
   int index = 0;
   for (std::list<EventMessage*>::iterator it =
            message_list.begin();
        it != message_list.end(); ++it) {

[awong, 2011/01/20 20:06:38]

Can you add a SCOPED_LOG in this, and the other for loops in this unittest file
to make sure we know which iteration we're on (or whatever other information is
required to pinpoint the failing input)?

[Sergey Ulanov, 2011/01/20 21:55:57]

Done.

     EventMessage* message = *it;
     // Partial update stream.
-    EXPECT_EQ(message->event_size(), 1);
-    EXPECT_TRUE(message->event(0).has_key());
+    EXPECT_TRUE(message->has_key());
 
     // TODO(sergeyu): Don't use index here. Instead store the expected values
     // in an array.
-    EXPECT_EQ(kTestKey + index, message->event(0).key().keycode());
-    EXPECT_EQ((index % 2) != 0, message->event(0).key().pressed());
+    EXPECT_EQ(kTestKey + index, message->key().keycode());
+    EXPECT_EQ((index % 2) != 0, message->key().pressed());
     ++index;
   }
   STLDeleteElements(&message_list);
 }
 
 TEST(MessageDecoderTest, SmallReads) {
   const int kReads[] = {1, 2, 3, 1};
   SimulateReadSequence(kReads, arraysize(kReads));
 }
 
 TEST(MessageDecoderTest, LargeReads) {
   const int kReads[] = {50, 50, 5};
   SimulateReadSequence(kReads, arraysize(kReads));
 }
 
 TEST(MessageDecoderTest, EmptyReads) {
   const int kReads[] = {4, 0, 50, 0};
   SimulateReadSequence(kReads, arraysize(kReads));
 }
 
 }  // namespace protocol
 }  // namespace remoting