Home | History | Annotate | Download | only in ipc 
      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
    153