ipc/ipc_message_unittest.cc

   1 // Copyright (c) 2012 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 "ipc/ipc_message.h"
   6
   7 #include <string.h>
   8
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/values.h"
  11 #include "ipc/ipc_message_utils.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 // IPC messages for testing ----------------------------------------------------
  15
  16 #define IPC_MESSAGE_IMPL
  17 #include "ipc/ipc_message_macros.h"
  18
  19 #define IPC_MESSAGE_START TestMsgStart
  20
  21 IPC_MESSAGE_CONTROL0(TestMsgClassEmpty)
  22
  23 IPC_MESSAGE_CONTROL1(TestMsgClassI, int)
  24
  25 IPC_SYNC_MESSAGE_CONTROL1_1(TestMsgClassIS, int, std::string)
  26
  27 namespace {
  28
  29 TEST(IPCMessageTest, ListValue) {
  30   base::ListValue input;
  31   input.Set(0, new base::FundamentalValue(42.42));
  32   input.Set(1, new base::StringValue("forty"));
  33   input.Set(2, base::Value::CreateNullValue());
  34
  35   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
  36   IPC::WriteParam(&msg, input);
  37
  38   base::ListValue output;
  39   PickleIterator iter(msg);
  40   EXPECT_TRUE(IPC::ReadParam(&msg, &iter, &output));
  41
  42   EXPECT_TRUE(input.Equals(&output));
  43
  44   // Also test the corrupt case.
  45   IPC::Message bad_msg(1, 2, IPC::Message::PRIORITY_NORMAL);
  46   bad_msg.WriteInt(99);
  47   iter = PickleIterator(bad_msg);
  48   EXPECT_FALSE(IPC::ReadParam(&bad_msg, &iter, &output));
  49 }
  50
  51 TEST(IPCMessageTest, DictionaryValue) {
  52   base::DictionaryValue input;
  53   input.Set("null", base::Value::CreateNullValue());
  54   input.Set("bool", new base::FundamentalValue(true));
  55   input.Set("int", new base::FundamentalValue(42));
  56   input.SetWithoutPathExpansion("int.with.dot", new base::FundamentalValue(43));
  57
  58   scoped_ptr<base::DictionaryValue> subdict(new base::DictionaryValue());
  59   subdict->Set("str", new base::StringValue("forty two"));
  60   subdict->Set("bool", new base::FundamentalValue(false));
  61
  62   scoped_ptr<base::ListValue> sublist(new base::ListValue());
  63   sublist->Set(0, new base::FundamentalValue(42.42));
  64   sublist->Set(1, new base::StringValue("forty"));
  65   sublist->Set(2, new base::StringValue("two"));
  66   subdict->Set("list", sublist.release());
  67
  68   input.Set("dict", subdict.release());
  69
  70   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
  71   IPC::WriteParam(&msg, input);
  72
  73   base::DictionaryValue output;
  74   PickleIterator iter(msg);
  75   EXPECT_TRUE(IPC::ReadParam(&msg, &iter, &output));
  76
  77   EXPECT_TRUE(input.Equals(&output));
  78
  79   // Also test the corrupt case.
  80   IPC::Message bad_msg(1, 2, IPC::Message::PRIORITY_NORMAL);
  81   bad_msg.WriteInt(99);
  82   iter = PickleIterator(bad_msg);
  83   EXPECT_FALSE(IPC::ReadParam(&bad_msg, &iter, &output));
  84 }
  85
  86 class IPCMessageParameterTest : public testing::Test {
  87  public:
  88   IPCMessageParameterTest() : extra_param_("extra_param"), called_(false) {}
  89
  90   bool OnMessageReceived(const IPC::Message& message) {
  91     bool handled = true;
  92     IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(IPCMessageParameterTest, message,
  93                                      &extra_param_)
  94       IPC_MESSAGE_HANDLER(TestMsgClassEmpty, OnEmpty)
  95       IPC_MESSAGE_HANDLER(TestMsgClassI, OnInt)
  96       //IPC_MESSAGE_HANDLER(TestMsgClassIS, OnSync)
  97       IPC_MESSAGE_UNHANDLED(handled = false)
  98     IPC_END_MESSAGE_MAP()
  99
 100     return handled;
 101   }
 102
 103   void OnEmpty(std::string* extra_param) {
 104     EXPECT_EQ(extra_param, &extra_param_);
 105     called_ = true;
 106   }
 107
 108   void OnInt(std::string* extra_param, int foo) {
 109     EXPECT_EQ(extra_param, &extra_param_);
 110     EXPECT_EQ(foo, 42);
 111     called_ = true;
 112   }
 113
 114   /* TODO: handle sync IPCs
 115     void OnSync(std::string* extra_param, int foo, std::string* out) {
 116     EXPECT_EQ(extra_param, &extra_param_);
 117     EXPECT_EQ(foo, 42);
 118     called_ = true;
 119     *out = std::string("out");
 120   }
 121
 122   bool Send(IPC::Message* reply) {
 123     delete reply;
 124     return true;
 125   }*/
 126
 127   std::string extra_param_;
 128   bool called_;
 129 };
 130
 131 TEST_F(IPCMessageParameterTest, EmptyDispatcherWithParam) {
 132   TestMsgClassEmpty message;
 133   EXPECT_TRUE(OnMessageReceived(message));
 134   EXPECT_TRUE(called_);
 135 }
 136
 137 TEST_F(IPCMessageParameterTest, OneIntegerWithParam) {
 138   TestMsgClassI message(42);
 139   EXPECT_TRUE(OnMessageReceived(message));
 140   EXPECT_TRUE(called_);
 141 }
 142
 143 /* TODO: handle sync IPCs
 144 TEST_F(IPCMessageParameterTest, Sync) {
 145   std::string output;
 146   TestMsgClassIS message(42, &output);
 147   EXPECT_TRUE(OnMessageReceived(message));
 148   EXPECT_TRUE(called_);
 149   EXPECT_EQ(output, std::string("out"));
 150 }*/
 151
 152 }  // namespace