remoting/host/native_messaging/native_messaging_writer_unittest.cc

   1 // Copyright 2013 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 "remoting/host/native_messaging/native_messaging_writer.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/json/json_reader.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/stl_util.h"
  11 #include "base/values.h"
  12 #include "remoting/host/setup/test_util.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace remoting {
  16
  17 class NativeMessagingWriterTest : public testing::Test {
  18  public:
  19   NativeMessagingWriterTest();
  20   ~NativeMessagingWriterTest() override;
  21
  22   void SetUp() override;
  23
  24  protected:
  25   scoped_ptr<NativeMessagingWriter> writer_;
  26   base::File read_file_;
  27   base::File write_file_;
  28 };
  29
  30 NativeMessagingWriterTest::NativeMessagingWriterTest() {}
  31
  32 NativeMessagingWriterTest::~NativeMessagingWriterTest() {}
  33
  34 void NativeMessagingWriterTest::SetUp() {
  35   ASSERT_TRUE(MakePipe(&read_file_, &write_file_));
  36   writer_.reset(new NativeMessagingWriter(write_file_.Pass()));
  37 }
  38
  39 TEST_F(NativeMessagingWriterTest, GoodMessage) {
  40   base::DictionaryValue message;
  41   message.SetInteger("foo", 42);
  42   EXPECT_TRUE(writer_->WriteMessage(message));
  43
  44   // Read from the pipe and verify the content.
  45   uint32 length;
  46   int read = read_file_.ReadAtCurrentPos(reinterpret_cast<char*>(&length), 4);
  47   EXPECT_EQ(4, read);
  48   std::string content(length, '\0');
  49   read = read_file_.ReadAtCurrentPos(string_as_array(&content), length);
  50   EXPECT_EQ(static_cast<int>(length), read);
  51
  52   // |content| should now contain serialized |message|.
  53   scoped_ptr<base::Value> written_message(base::JSONReader::Read(content));
  54   EXPECT_TRUE(message.Equals(written_message.get()));
  55
  56   // Nothing more should have been written. Close the write-end of the pipe,
  57   // and verify the read end immediately hits EOF.
  58   writer_.reset(nullptr);
  59   char unused;
  60   read = read_file_.ReadAtCurrentPos(&unused, 1);
  61   EXPECT_LE(read, 0);
  62 }
  63
  64 TEST_F(NativeMessagingWriterTest, SecondMessage) {
  65   base::DictionaryValue message1;
  66   base::DictionaryValue message2;
  67   message2.SetInteger("foo", 42);
  68   EXPECT_TRUE(writer_->WriteMessage(message1));
  69   EXPECT_TRUE(writer_->WriteMessage(message2));
  70   writer_.reset(nullptr);
  71
  72   // Read two messages.
  73   uint32 length;
  74   int read;
  75   std::string content;
  76   for (int i = 0; i < 2; i++) {
  77     read = read_file_.ReadAtCurrentPos(reinterpret_cast<char*>(&length), 4);
  78     EXPECT_EQ(4, read) << "i = " << i;
  79     content.resize(length);
  80     read = read_file_.ReadAtCurrentPos(string_as_array(&content), length);
  81     EXPECT_EQ(static_cast<int>(length), read) << "i = " << i;
  82   }
  83
  84   // |content| should now contain serialized |message2|.
  85   scoped_ptr<base::Value> written_message2(base::JSONReader::Read(content));
  86   EXPECT_TRUE(message2.Equals(written_message2.get()));
  87 }
  88
  89 TEST_F(NativeMessagingWriterTest, FailedWrite) {
  90   // Close the read end so that writing fails immediately.
  91   read_file_.Close();
  92
  93   base::DictionaryValue message;
  94   EXPECT_FALSE(writer_->WriteMessage(message));
  95 }
  96
  97 }  // namespace remoting