123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320 |
- // Copyright (c) 2012 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 "ipc/ipc_message.h"
- #include <stddef.h>
- #include <stdint.h>
- #include <string.h>
- #include <limits>
- #include <memory>
- #include <utility>
- #include "base/memory/ptr_util.h"
- #include "base/strings/utf_string_conversions.h"
- #include "base/values.h"
- #include "build/build_config.h"
- #include "ipc/ipc_message_utils.h"
- #include "testing/gtest/include/gtest/gtest.h"
- // IPC messages for testing ----------------------------------------------------
- #define IPC_MESSAGE_IMPL
- #include "ipc/ipc_message_macros.h"
- #include "ipc/ipc_message_start.h"
- #define IPC_MESSAGE_START TestMsgStart
- IPC_MESSAGE_CONTROL0(TestMsgClassEmpty)
- IPC_MESSAGE_CONTROL1(TestMsgClassI, int)
- IPC_SYNC_MESSAGE_CONTROL1_1(TestMsgClassIS, int, std::string)
- namespace IPC {
- TEST(IPCMessageTest, BasicMessageTest) {
- int v1 = 10;
- std::string v2("foobar");
- std::u16string v3(u"hello world");
- IPC::Message m(0, 1, IPC::Message::PRIORITY_NORMAL);
- m.WriteInt(v1);
- m.WriteString(v2);
- m.WriteString16(v3);
- base::PickleIterator iter(m);
- int vi;
- std::string vs;
- std::u16string vs16;
- EXPECT_TRUE(iter.ReadInt(&vi));
- EXPECT_EQ(v1, vi);
- EXPECT_TRUE(iter.ReadString(&vs));
- EXPECT_EQ(v2, vs);
- EXPECT_TRUE(iter.ReadString16(&vs16));
- EXPECT_EQ(v3, vs16);
- // should fail
- EXPECT_FALSE(iter.ReadInt(&vi));
- EXPECT_FALSE(iter.ReadString(&vs));
- EXPECT_FALSE(iter.ReadString16(&vs16));
- }
- TEST(IPCMessageTest, Value) {
- auto expect_value_equals = [](const base::Value& input) {
- IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
- IPC::WriteParam(&msg, input);
- base::Value output;
- base::PickleIterator iter(msg);
- EXPECT_TRUE(IPC::ReadParam(&msg, &iter, &output)) << input;
- EXPECT_EQ(input, output);
- };
- expect_value_equals(base::Value("foo"));
- expect_value_equals(base::Value(42));
- expect_value_equals(base::Value(0.07));
- expect_value_equals(base::Value(true));
- expect_value_equals(base::Value(base::Value::BlobStorage({'a', 'b', 'c'})));
- {
- base::Value dict(base::Value::Type::DICTIONARY);
- dict.SetIntKey("key1", 42);
- dict.SetStringKey("key2", "hi");
- expect_value_equals(dict);
- }
- {
- base::Value list(base::Value::Type::LIST);
- list.GetList().Append(42);
- list.GetList().Append("hello");
- expect_value_equals(list);
- }
- // Also test the corrupt case.
- IPC::Message bad_msg(1, 2, IPC::Message::PRIORITY_NORMAL);
- bad_msg.WriteInt(99);
- base::PickleIterator iter(bad_msg);
- base::Value output;
- EXPECT_FALSE(IPC::ReadParam(&bad_msg, &iter, &output));
- }
- TEST(IPCMessageTest, ListValue) {
- base::ListValue input;
- input.GetList().Append(42.42);
- input.GetList().Append("forty");
- input.GetList().Append(base::Value());
- IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
- IPC::WriteParam(&msg, input);
- base::ListValue output;
- base::PickleIterator iter(msg);
- EXPECT_TRUE(IPC::ReadParam(&msg, &iter, &output));
- EXPECT_EQ(input, output);
- // Also test the corrupt case.
- IPC::Message bad_msg(1, 2, IPC::Message::PRIORITY_NORMAL);
- bad_msg.WriteInt(99);
- iter = base::PickleIterator(bad_msg);
- EXPECT_FALSE(IPC::ReadParam(&bad_msg, &iter, &output));
- }
- TEST(IPCMessageTest, DictionaryValue) {
- base::DictionaryValue input;
- input.SetKey("null", base::Value());
- input.SetBoolean("bool", true);
- input.GetDict().Set("int", 42);
- input.SetKey("int.with.dot", base::Value(43));
- base::DictionaryValue subdict;
- subdict.SetString("str", "forty two");
- subdict.SetBoolean("bool", false);
- base::ListValue sublist;
- sublist.GetList().Append(42.42);
- sublist.GetList().Append("forty");
- sublist.GetList().Append("two");
- subdict.SetKey("list", std::move(sublist));
- input.SetKey("dict", std::move(subdict));
- IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
- IPC::WriteParam(&msg, input);
- base::DictionaryValue output;
- base::PickleIterator iter(msg);
- EXPECT_TRUE(IPC::ReadParam(&msg, &iter, &output));
- EXPECT_EQ(input, output);
- // Also test the corrupt case.
- IPC::Message bad_msg(1, 2, IPC::Message::PRIORITY_NORMAL);
- bad_msg.WriteInt(99);
- iter = base::PickleIterator(bad_msg);
- EXPECT_FALSE(IPC::ReadParam(&bad_msg, &iter, &output));
- }
- TEST(IPCMessageTest, FindNext) {
- IPC::Message message;
- message.WriteString("Goooooooogle");
- message.WriteInt(111);
- std::vector<char> message_data(message.size() + 7);
- memcpy(message_data.data(), message.data(), message.size());
- const char* data_start = message_data.data();
- const char* data_end = data_start + message.size();
- IPC::Message::NextMessageInfo next;
- // Data range contains the entire message plus some extra bytes
- IPC::Message::FindNext(data_start, data_end + 1, &next);
- EXPECT_TRUE(next.message_found);
- EXPECT_EQ(next.message_size, message.size());
- EXPECT_EQ(next.pickle_end, data_end);
- EXPECT_EQ(next.message_end, data_end);
- // Data range exactly contains the entire message
- IPC::Message::FindNext(data_start, data_end, &next);
- EXPECT_TRUE(next.message_found);
- EXPECT_EQ(next.message_size, message.size());
- EXPECT_EQ(next.pickle_end, data_end);
- EXPECT_EQ(next.message_end, data_end);
- // Data range doesn't contain the entire message
- // (but contains the message header)
- IPC::Message::FindNext(data_start, data_end - 1, &next);
- EXPECT_FALSE(next.message_found);
- EXPECT_EQ(next.message_size, message.size());
- // Data range doesn't contain the message header
- // (but contains the pickle header)
- IPC::Message::FindNext(data_start,
- data_start + sizeof(IPC::Message::Header) - 1,
- &next);
- EXPECT_FALSE(next.message_found);
- EXPECT_EQ(next.message_size, 0u);
- // Data range doesn't contain the pickle header
- IPC::Message::FindNext(data_start,
- data_start + sizeof(base::Pickle::Header) - 1,
- &next);
- EXPECT_FALSE(next.message_found);
- EXPECT_EQ(next.message_size, 0u);
- }
- TEST(IPCMessageTest, FindNextOverflow) {
- IPC::Message message;
- message.WriteString("Data");
- message.WriteInt(777);
- const char* data_start = reinterpret_cast<const char*>(message.data());
- const char* data_end = data_start + message.size();
- IPC::Message::NextMessageInfo next;
- // Payload size is negative (defeats 'start + size > end' check)
- message.header()->payload_size = static_cast<uint32_t>(-1);
- IPC::Message::FindNext(data_start, data_end, &next);
- EXPECT_FALSE(next.message_found);
- if (sizeof(size_t) > sizeof(uint32_t)) {
- // No overflow, just insane message size
- EXPECT_EQ(next.message_size,
- message.header()->payload_size + sizeof(IPC::Message::Header));
- } else {
- // Actual overflow, reported as max size_t
- EXPECT_EQ(next.message_size, std::numeric_limits<size_t>::max());
- }
- // Payload size is max positive integer (defeats size < 0 check, while
- // still potentially causing overflow down the road).
- message.header()->payload_size = std::numeric_limits<int32_t>::max();
- IPC::Message::FindNext(data_start, data_end, &next);
- EXPECT_FALSE(next.message_found);
- EXPECT_EQ(next.message_size,
- message.header()->payload_size + sizeof(IPC::Message::Header));
- }
- namespace {
- class IPCMessageParameterTest : public testing::Test {
- public:
- IPCMessageParameterTest() : extra_param_("extra_param"), called_(false) {}
- bool OnMessageReceived(const IPC::Message& message) {
- bool handled = true;
- IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(IPCMessageParameterTest, message,
- &extra_param_)
- IPC_MESSAGE_HANDLER(TestMsgClassEmpty, OnEmpty)
- IPC_MESSAGE_HANDLER(TestMsgClassI, OnInt)
- //IPC_MESSAGE_HANDLER(TestMsgClassIS, OnSync)
- IPC_MESSAGE_UNHANDLED(handled = false)
- IPC_END_MESSAGE_MAP()
- return handled;
- }
- void OnEmpty(std::string* extra_param) {
- EXPECT_EQ(extra_param, &extra_param_);
- called_ = true;
- }
- void OnInt(std::string* extra_param, int foo) {
- EXPECT_EQ(extra_param, &extra_param_);
- EXPECT_EQ(foo, 42);
- called_ = true;
- }
- /* TODO: handle sync IPCs
- void OnSync(std::string* extra_param, int foo, std::string* out) {
- EXPECT_EQ(extra_param, &extra_param_);
- EXPECT_EQ(foo, 42);
- called_ = true;
- *out = std::string("out");
- }
- bool Send(IPC::Message* reply) {
- delete reply;
- return true;
- }*/
- std::string extra_param_;
- bool called_;
- };
- } // namespace
- TEST_F(IPCMessageParameterTest, EmptyDispatcherWithParam) {
- TestMsgClassEmpty message;
- EXPECT_TRUE(OnMessageReceived(message));
- EXPECT_TRUE(called_);
- }
- #if BUILDFLAG(IS_ANDROID)
- #define MAYBE_OneIntegerWithParam DISABLED_OneIntegerWithParam
- #else
- #define MAYBE_OneIntegerWithParam OneIntegerWithParam
- #endif
- TEST_F(IPCMessageParameterTest, MAYBE_OneIntegerWithParam) {
- TestMsgClassI message(42);
- EXPECT_TRUE(OnMessageReceived(message));
- EXPECT_TRUE(called_);
- }
- /* TODO: handle sync IPCs
- TEST_F(IPCMessageParameterTest, Sync) {
- std::string output;
- TestMsgClassIS message(42, &output);
- EXPECT_TRUE(OnMessageReceived(message));
- EXPECT_TRUE(called_);
- EXPECT_EQ(output, std::string("out"));
- }*/
- } // namespace IPC
|