123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727 |
- // 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 "dbus/message.h"
- #include <stddef.h>
- #include <stdint.h>
- #include <memory>
- #include "base/logging.h"
- #include "base/posix/eintr_wrapper.h"
- #include "dbus/object_path.h"
- #include "dbus/test_proto.pb.h"
- #include "testing/gtest/include/gtest/gtest.h"
- namespace dbus {
- // Test that a byte can be properly written and read. We only have this
- // test for byte, as repeating this for other basic types is too redundant.
- TEST(MessageTest, AppendAndPopByte) {
- std::unique_ptr<Response> message(Response::CreateEmpty());
- MessageWriter writer(message.get());
- writer.AppendByte(123); // The input is 123.
- MessageReader reader(message.get());
- ASSERT_TRUE(reader.HasMoreData()); // Should have data to read.
- ASSERT_EQ(Message::BYTE, reader.GetDataType());
- ASSERT_EQ("y", reader.GetDataSignature());
- bool bool_value = false;
- // Should fail as the type is not bool here.
- ASSERT_FALSE(reader.PopBool(&bool_value));
- uint8_t byte_value = 0;
- ASSERT_TRUE(reader.PopByte(&byte_value));
- EXPECT_EQ(123, byte_value); // Should match with the input.
- ASSERT_FALSE(reader.HasMoreData()); // Should not have more data to read.
- // Try to get another byte. Should fail.
- ASSERT_FALSE(reader.PopByte(&byte_value));
- }
- // Check all basic types can be properly written and read.
- TEST(MessageTest, AppendAndPopBasicDataTypes) {
- std::unique_ptr<Response> message(Response::CreateEmpty());
- MessageWriter writer(message.get());
- // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path".
- writer.AppendByte(0);
- writer.AppendBool(true);
- writer.AppendInt16(2);
- writer.AppendUint16(3);
- writer.AppendInt32(4);
- writer.AppendUint32(5);
- writer.AppendInt64(6);
- writer.AppendUint64(7);
- writer.AppendDouble(8.0);
- writer.AppendString("string");
- writer.AppendObjectPath(ObjectPath("/object/path"));
- uint8_t byte_value = 0;
- bool bool_value = false;
- int16_t int16_value = 0;
- uint16_t uint16_value = 0;
- int32_t int32_value = 0;
- uint32_t uint32_value = 0;
- int64_t int64_value = 0;
- uint64_t uint64_value = 0;
- double double_value = 0;
- std::string string_value;
- ObjectPath object_path_value;
- MessageReader reader(message.get());
- ASSERT_TRUE(reader.HasMoreData());
- ASSERT_EQ("y", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopByte(&byte_value));
- ASSERT_EQ("b", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopBool(&bool_value));
- ASSERT_EQ("n", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopInt16(&int16_value));
- ASSERT_EQ("q", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopUint16(&uint16_value));
- ASSERT_EQ("i", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopInt32(&int32_value));
- ASSERT_EQ("u", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopUint32(&uint32_value));
- ASSERT_EQ("x", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopInt64(&int64_value));
- ASSERT_EQ("t", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopUint64(&uint64_value));
- ASSERT_EQ("d", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopDouble(&double_value));
- ASSERT_EQ("s", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopString(&string_value));
- ASSERT_EQ("o", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopObjectPath(&object_path_value));
- ASSERT_EQ("", reader.GetDataSignature());
- ASSERT_FALSE(reader.HasMoreData());
- // 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path" should be returned.
- EXPECT_EQ(0, byte_value);
- EXPECT_EQ(true, bool_value);
- EXPECT_EQ(2, int16_value);
- EXPECT_EQ(3U, uint16_value);
- EXPECT_EQ(4, int32_value);
- EXPECT_EQ(5U, uint32_value);
- EXPECT_EQ(6, int64_value);
- EXPECT_EQ(7U, uint64_value);
- EXPECT_DOUBLE_EQ(8.0, double_value);
- EXPECT_EQ("string", string_value);
- EXPECT_EQ(ObjectPath("/object/path"), object_path_value);
- }
- // Check all basic types can be properly written and read.
- TEST(MessageTest, AppendAndPopFileDescriptor) {
- if (!IsDBusTypeUnixFdSupported()) {
- LOG(WARNING) << "FD passing is not supported";
- return;
- }
- std::unique_ptr<Response> message(Response::CreateEmpty());
- MessageWriter writer(message.get());
- // Append stdout.
- const int fd_in = 1;
- writer.AppendFileDescriptor(fd_in);
- base::ScopedFD fd_out;
- MessageReader reader(message.get());
- ASSERT_TRUE(reader.HasMoreData());
- ASSERT_EQ(Message::UNIX_FD, reader.GetDataType());
- ASSERT_EQ("h", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopFileDescriptor(&fd_out));
- ASSERT_FALSE(reader.HasMoreData());
- // Stdout should be returned but we cannot check the descriptor
- // value because stdout will be dup'd. Instead check st_rdev
- // which should be identical.
- struct stat sb_stdout;
- int status_stdout = HANDLE_EINTR(fstat(fd_in, &sb_stdout));
- ASSERT_GE(status_stdout, 0);
- struct stat sb_fd;
- int status_fd = HANDLE_EINTR(fstat(fd_out.get(), &sb_fd));
- ASSERT_GE(status_fd, 0);
- EXPECT_EQ(sb_stdout.st_rdev, sb_fd.st_rdev);
- }
- // Check all variant types can be properly written and read.
- TEST(MessageTest, AppendAndPopVariantDataTypes) {
- std::unique_ptr<Response> message(Response::CreateEmpty());
- MessageWriter writer(message.get());
- // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path".
- writer.AppendVariantOfByte(0);
- writer.AppendVariantOfBool(true);
- writer.AppendVariantOfInt16(2);
- writer.AppendVariantOfUint16(3);
- writer.AppendVariantOfInt32(4);
- writer.AppendVariantOfUint32(5);
- writer.AppendVariantOfInt64(6);
- writer.AppendVariantOfUint64(7);
- writer.AppendVariantOfDouble(8.0);
- writer.AppendVariantOfString("string");
- writer.AppendVariantOfObjectPath(ObjectPath("/object/path"));
- uint8_t byte_value = 0;
- bool bool_value = false;
- int16_t int16_value = 0;
- uint16_t uint16_value = 0;
- int32_t int32_value = 0;
- uint32_t uint32_value = 0;
- int64_t int64_value = 0;
- uint64_t uint64_value = 0;
- double double_value = 0;
- std::string string_value;
- ObjectPath object_path_value;
- MessageReader reader(message.get());
- ASSERT_TRUE(reader.HasMoreData());
- ASSERT_EQ("v", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopVariantOfByte(&byte_value));
- ASSERT_EQ("v", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopVariantOfBool(&bool_value));
- ASSERT_EQ("v", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopVariantOfInt16(&int16_value));
- ASSERT_EQ("v", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopVariantOfUint16(&uint16_value));
- ASSERT_EQ("v", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopVariantOfInt32(&int32_value));
- ASSERT_EQ("v", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopVariantOfUint32(&uint32_value));
- ASSERT_EQ("v", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopVariantOfInt64(&int64_value));
- ASSERT_EQ("v", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopVariantOfUint64(&uint64_value));
- ASSERT_EQ("v", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopVariantOfDouble(&double_value));
- ASSERT_EQ("v", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopVariantOfString(&string_value));
- ASSERT_EQ("v", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopVariantOfObjectPath(&object_path_value));
- ASSERT_EQ("", reader.GetDataSignature());
- ASSERT_FALSE(reader.HasMoreData());
- // 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path" should be returned.
- EXPECT_EQ(0, byte_value);
- EXPECT_EQ(true, bool_value);
- EXPECT_EQ(2, int16_value);
- EXPECT_EQ(3U, uint16_value);
- EXPECT_EQ(4, int32_value);
- EXPECT_EQ(5U, uint32_value);
- EXPECT_EQ(6, int64_value);
- EXPECT_EQ(7U, uint64_value);
- EXPECT_DOUBLE_EQ(8.0, double_value);
- EXPECT_EQ("string", string_value);
- EXPECT_EQ(ObjectPath("/object/path"), object_path_value);
- }
- TEST(MessageTest, ArrayOfBytes) {
- std::unique_ptr<Response> message(Response::CreateEmpty());
- MessageWriter writer(message.get());
- std::vector<uint8_t> bytes;
- bytes.push_back(1);
- bytes.push_back(2);
- bytes.push_back(3);
- writer.AppendArrayOfBytes(bytes.data(), bytes.size());
- MessageReader reader(message.get());
- const uint8_t* output_bytes = nullptr;
- size_t length = 0;
- ASSERT_EQ("ay", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopArrayOfBytes(&output_bytes, &length));
- ASSERT_FALSE(reader.HasMoreData());
- ASSERT_EQ(3U, length);
- EXPECT_EQ(1, output_bytes[0]);
- EXPECT_EQ(2, output_bytes[1]);
- EXPECT_EQ(3, output_bytes[2]);
- }
- TEST(MessageTest, ArrayOfInt32s) {
- std::unique_ptr<Response> message(Response::CreateEmpty());
- MessageWriter writer(message.get());
- std::vector<int32_t> int32s;
- int32s.push_back(1);
- int32s.push_back(2);
- int32s.push_back(3);
- writer.AppendArrayOfInt32s(int32s.data(), int32s.size());
- MessageReader reader(message.get());
- const int32_t* output_int32s = nullptr;
- size_t length = 0;
- ASSERT_EQ("ai", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopArrayOfInt32s(&output_int32s, &length));
- ASSERT_FALSE(reader.HasMoreData());
- ASSERT_EQ(3U, length);
- EXPECT_EQ(1, output_int32s[0]);
- EXPECT_EQ(2, output_int32s[1]);
- EXPECT_EQ(3, output_int32s[2]);
- }
- TEST(MessageTest, ArrayOfUint32s) {
- std::unique_ptr<Response> message(Response::CreateEmpty());
- MessageWriter writer(message.get());
- std::vector<uint32_t> uint32s;
- uint32s.push_back(1);
- uint32s.push_back(2);
- uint32s.push_back(3);
- writer.AppendArrayOfUint32s(uint32s.data(), uint32s.size());
- MessageReader reader(message.get());
- const uint32_t* output_uint32s = nullptr;
- size_t length = 0;
- ASSERT_EQ("au", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopArrayOfUint32s(&output_uint32s, &length));
- ASSERT_FALSE(reader.HasMoreData());
- ASSERT_EQ(3U, length);
- EXPECT_EQ(1U, output_uint32s[0]);
- EXPECT_EQ(2U, output_uint32s[1]);
- EXPECT_EQ(3U, output_uint32s[2]);
- }
- TEST(MessageTest, ArrayOfDoubles) {
- std::unique_ptr<Response> message(Response::CreateEmpty());
- MessageWriter writer(message.get());
- std::vector<double> doubles;
- doubles.push_back(0.2);
- doubles.push_back(0.5);
- doubles.push_back(1);
- writer.AppendArrayOfDoubles(doubles.data(), doubles.size());
- MessageReader reader(message.get());
- const double* output_doubles = nullptr;
- size_t length = 0;
- ASSERT_EQ("ad", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopArrayOfDoubles(&output_doubles, &length));
- ASSERT_FALSE(reader.HasMoreData());
- ASSERT_EQ(3U, length);
- EXPECT_EQ(0.2, output_doubles[0]);
- EXPECT_EQ(0.5, output_doubles[1]);
- EXPECT_EQ(1, output_doubles[2]);
- }
- TEST(MessageTest, ArrayOfBytes_Empty) {
- std::unique_ptr<Response> message(Response::CreateEmpty());
- MessageWriter writer(message.get());
- std::vector<uint8_t> bytes;
- writer.AppendArrayOfBytes(bytes.data(), bytes.size());
- MessageReader reader(message.get());
- const uint8_t* output_bytes = nullptr;
- size_t length = 0;
- ASSERT_EQ("ay", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopArrayOfBytes(&output_bytes, &length));
- ASSERT_FALSE(reader.HasMoreData());
- ASSERT_EQ(0U, length);
- EXPECT_EQ(nullptr, output_bytes);
- }
- TEST(MessageTest, ArrayOfStrings) {
- std::unique_ptr<Response> message(Response::CreateEmpty());
- MessageWriter writer(message.get());
- std::vector<std::string> strings;
- strings.push_back("fee");
- strings.push_back("fie");
- strings.push_back("foe");
- strings.push_back("fum");
- writer.AppendArrayOfStrings(strings);
- MessageReader reader(message.get());
- std::vector<std::string> output_strings;
- ASSERT_EQ("as", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopArrayOfStrings(&output_strings));
- ASSERT_FALSE(reader.HasMoreData());
- ASSERT_EQ(4U, output_strings.size());
- EXPECT_EQ("fee", output_strings[0]);
- EXPECT_EQ("fie", output_strings[1]);
- EXPECT_EQ("foe", output_strings[2]);
- EXPECT_EQ("fum", output_strings[3]);
- }
- TEST(MessageTest, ArrayOfObjectPaths) {
- std::unique_ptr<Response> message(Response::CreateEmpty());
- MessageWriter writer(message.get());
- std::vector<ObjectPath> object_paths;
- object_paths.push_back(ObjectPath("/object/path/1"));
- object_paths.push_back(ObjectPath("/object/path/2"));
- object_paths.push_back(ObjectPath("/object/path/3"));
- writer.AppendArrayOfObjectPaths(object_paths);
- MessageReader reader(message.get());
- std::vector<ObjectPath> output_object_paths;
- ASSERT_EQ("ao", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopArrayOfObjectPaths(&output_object_paths));
- ASSERT_FALSE(reader.HasMoreData());
- ASSERT_EQ(3U, output_object_paths.size());
- EXPECT_EQ(ObjectPath("/object/path/1"), output_object_paths[0]);
- EXPECT_EQ(ObjectPath("/object/path/2"), output_object_paths[1]);
- EXPECT_EQ(ObjectPath("/object/path/3"), output_object_paths[2]);
- }
- TEST(MessageTest, ProtoBuf) {
- std::unique_ptr<Response> message(Response::CreateEmpty());
- MessageWriter writer(message.get());
- TestProto send_message;
- send_message.set_text("testing");
- send_message.set_number(123);
- writer.AppendProtoAsArrayOfBytes(send_message);
- MessageReader reader(message.get());
- TestProto receive_message;
- ASSERT_EQ("ay", reader.GetDataSignature());
- ASSERT_TRUE(reader.PopArrayOfBytesAsProto(&receive_message));
- EXPECT_EQ(receive_message.text(), send_message.text());
- EXPECT_EQ(receive_message.number(), send_message.number());
- }
- // Test that an array can be properly written and read. We only have this
- // test for array, as repeating this for other container types is too
- // redundant.
- TEST(MessageTest, OpenArrayAndPopArray) {
- std::unique_ptr<Response> message(Response::CreateEmpty());
- MessageWriter writer(message.get());
- MessageWriter array_writer(nullptr);
- writer.OpenArray("s", &array_writer); // Open an array of strings.
- array_writer.AppendString("foo");
- array_writer.AppendString("bar");
- array_writer.AppendString("baz");
- writer.CloseContainer(&array_writer);
- MessageReader reader(message.get());
- ASSERT_EQ(Message::ARRAY, reader.GetDataType());
- ASSERT_EQ("as", reader.GetDataSignature());
- MessageReader array_reader(nullptr);
- ASSERT_TRUE(reader.PopArray(&array_reader));
- ASSERT_FALSE(reader.HasMoreData()); // Should not have more data to read.
- std::string string_value;
- ASSERT_TRUE(array_reader.PopString(&string_value));
- EXPECT_EQ("foo", string_value);
- ASSERT_TRUE(array_reader.PopString(&string_value));
- EXPECT_EQ("bar", string_value);
- ASSERT_TRUE(array_reader.PopString(&string_value));
- EXPECT_EQ("baz", string_value);
- // Should not have more data to read.
- ASSERT_FALSE(array_reader.HasMoreData());
- }
- // Create a complex message using array, struct, variant, dict entry, and
- // make sure it can be read properly.
- TEST(MessageTest, CreateComplexMessageAndReadIt) {
- std::unique_ptr<Response> message(Response::CreateEmpty());
- MessageWriter writer(message.get());
- {
- MessageWriter array_writer(nullptr);
- // Open an array of variants.
- writer.OpenArray("v", &array_writer);
- {
- // The first value in the array.
- {
- MessageWriter variant_writer(nullptr);
- // Open a variant of a boolean.
- array_writer.OpenVariant("b", &variant_writer);
- variant_writer.AppendBool(true);
- array_writer.CloseContainer(&variant_writer);
- }
- // The second value in the array.
- {
- MessageWriter variant_writer(nullptr);
- // Open a variant of a struct that contains a string and an int32_t.
- array_writer.OpenVariant("(si)", &variant_writer);
- {
- MessageWriter struct_writer(nullptr);
- variant_writer.OpenStruct(&struct_writer);
- struct_writer.AppendString("string");
- struct_writer.AppendInt32(123);
- variant_writer.CloseContainer(&struct_writer);
- }
- array_writer.CloseContainer(&variant_writer);
- }
- // The third value in the array.
- {
- MessageWriter variant_writer(nullptr);
- // Open a variant of an array of string-to-int64_t dict entries.
- array_writer.OpenVariant("a{sx}", &variant_writer);
- {
- // Opens an array of string-to-int64_t dict entries.
- MessageWriter dict_array_writer(nullptr);
- variant_writer.OpenArray("{sx}", &dict_array_writer);
- {
- // Opens a string-to-int64_t dict entries.
- MessageWriter dict_entry_writer(nullptr);
- dict_array_writer.OpenDictEntry(&dict_entry_writer);
- dict_entry_writer.AppendString("foo");
- dict_entry_writer.AppendInt64(INT64_C(1234567890123456789));
- dict_array_writer.CloseContainer(&dict_entry_writer);
- }
- variant_writer.CloseContainer(&dict_array_writer);
- }
- array_writer.CloseContainer(&variant_writer);
- }
- }
- writer.CloseContainer(&array_writer);
- }
- // What we have created looks like this:
- EXPECT_EQ(
- "message_type: MESSAGE_METHOD_RETURN\n"
- "signature: av\n"
- "\n"
- "array [\n"
- " variant bool true\n"
- " variant struct {\n"
- " string \"string\"\n"
- " int32_t 123\n"
- " }\n"
- " variant array [\n"
- " dict entry {\n"
- " string \"foo\"\n"
- " int64_t 1234567890123456789\n"
- " }\n"
- " ]\n"
- "]\n",
- message->ToString());
- MessageReader reader(message.get());
- ASSERT_EQ("av", reader.GetDataSignature());
- MessageReader array_reader(nullptr);
- ASSERT_TRUE(reader.PopArray(&array_reader));
- // The first value in the array.
- bool bool_value = false;
- ASSERT_EQ("v", array_reader.GetDataSignature());
- ASSERT_TRUE(array_reader.PopVariantOfBool(&bool_value));
- EXPECT_EQ(true, bool_value);
- // The second value in the array.
- {
- MessageReader variant_reader(nullptr);
- ASSERT_TRUE(array_reader.PopVariant(&variant_reader));
- {
- MessageReader struct_reader(nullptr);
- ASSERT_EQ("(si)", variant_reader.GetDataSignature());
- ASSERT_TRUE(variant_reader.PopStruct(&struct_reader));
- std::string string_value;
- ASSERT_TRUE(struct_reader.PopString(&string_value));
- EXPECT_EQ("string", string_value);
- int32_t int32_value = 0;
- ASSERT_TRUE(struct_reader.PopInt32(&int32_value));
- EXPECT_EQ(123, int32_value);
- ASSERT_FALSE(struct_reader.HasMoreData());
- }
- ASSERT_FALSE(variant_reader.HasMoreData());
- }
- // The third value in the array.
- {
- MessageReader variant_reader(nullptr);
- ASSERT_TRUE(array_reader.PopVariant(&variant_reader));
- {
- MessageReader dict_array_reader(nullptr);
- ASSERT_EQ("a{sx}", variant_reader.GetDataSignature());
- ASSERT_TRUE(variant_reader.PopArray(&dict_array_reader));
- {
- MessageReader dict_entry_reader(nullptr);
- ASSERT_TRUE(dict_array_reader.PopDictEntry(&dict_entry_reader));
- std::string string_value;
- ASSERT_TRUE(dict_entry_reader.PopString(&string_value));
- EXPECT_EQ("foo", string_value);
- int64_t int64_value = 0;
- ASSERT_TRUE(dict_entry_reader.PopInt64(&int64_value));
- EXPECT_EQ(INT64_C(1234567890123456789), int64_value);
- }
- ASSERT_FALSE(dict_array_reader.HasMoreData());
- }
- ASSERT_FALSE(variant_reader.HasMoreData());
- }
- ASSERT_FALSE(array_reader.HasMoreData());
- ASSERT_FALSE(reader.HasMoreData());
- }
- TEST(MessageTest, MethodCall) {
- MethodCall method_call("com.example.Interface", "SomeMethod");
- EXPECT_NE(nullptr, method_call.raw_message());
- EXPECT_EQ(Message::MESSAGE_METHOD_CALL, method_call.GetMessageType());
- EXPECT_EQ("MESSAGE_METHOD_CALL", method_call.GetMessageTypeAsString());
- method_call.SetDestination("com.example.Service");
- method_call.SetPath(ObjectPath("/com/example/Object"));
- MessageWriter writer(&method_call);
- writer.AppendString("payload");
- EXPECT_EQ(
- "message_type: MESSAGE_METHOD_CALL\n"
- "destination: com.example.Service\n"
- "path: /com/example/Object\n"
- "interface: com.example.Interface\n"
- "member: SomeMethod\n"
- "signature: s\n"
- "\n"
- "string \"payload\"\n",
- method_call.ToString());
- }
- TEST(MessageTest, MethodCall_FromRawMessage) {
- DBusMessage* raw_message = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
- dbus_message_set_interface(raw_message, "com.example.Interface");
- dbus_message_set_member(raw_message, "SomeMethod");
- std::unique_ptr<MethodCall> method_call(
- MethodCall::FromRawMessage(raw_message));
- EXPECT_EQ("com.example.Interface", method_call->GetInterface());
- EXPECT_EQ("SomeMethod", method_call->GetMember());
- }
- TEST(MessageTest, Signal) {
- Signal signal("com.example.Interface", "SomeSignal");
- EXPECT_NE(nullptr, signal.raw_message());
- EXPECT_EQ(Message::MESSAGE_SIGNAL, signal.GetMessageType());
- EXPECT_EQ("MESSAGE_SIGNAL", signal.GetMessageTypeAsString());
- signal.SetPath(ObjectPath("/com/example/Object"));
- MessageWriter writer(&signal);
- writer.AppendString("payload");
- EXPECT_EQ(
- "message_type: MESSAGE_SIGNAL\n"
- "path: /com/example/Object\n"
- "interface: com.example.Interface\n"
- "member: SomeSignal\n"
- "signature: s\n"
- "\n"
- "string \"payload\"\n",
- signal.ToString());
- }
- TEST(MessageTest, Signal_FromRawMessage) {
- DBusMessage* raw_message = dbus_message_new(DBUS_MESSAGE_TYPE_SIGNAL);
- dbus_message_set_interface(raw_message, "com.example.Interface");
- dbus_message_set_member(raw_message, "SomeSignal");
- std::unique_ptr<Signal> signal(Signal::FromRawMessage(raw_message));
- EXPECT_EQ("com.example.Interface", signal->GetInterface());
- EXPECT_EQ("SomeSignal", signal->GetMember());
- }
- TEST(MessageTest, Response) {
- std::unique_ptr<Response> response(Response::CreateEmpty());
- EXPECT_TRUE(response->raw_message());
- EXPECT_EQ(Message::MESSAGE_METHOD_RETURN, response->GetMessageType());
- EXPECT_EQ("MESSAGE_METHOD_RETURN", response->GetMessageTypeAsString());
- }
- TEST(MessageTest, Response_FromMethodCall) {
- const uint32_t kSerial = 123;
- MethodCall method_call("com.example.Interface", "SomeMethod");
- method_call.SetSerial(kSerial);
- std::unique_ptr<Response> response(Response::FromMethodCall(&method_call));
- EXPECT_EQ(Message::MESSAGE_METHOD_RETURN, response->GetMessageType());
- EXPECT_EQ("MESSAGE_METHOD_RETURN", response->GetMessageTypeAsString());
- // The serial should be copied to the reply serial.
- EXPECT_EQ(kSerial, response->GetReplySerial());
- }
- TEST(MessageTest, ErrorResponse_FromMethodCall) {
- const uint32_t kSerial = 123;
- const char kErrorMessage[] = "error message";
- MethodCall method_call("com.example.Interface", "SomeMethod");
- method_call.SetSerial(kSerial);
- std::unique_ptr<ErrorResponse> error_response(ErrorResponse::FromMethodCall(
- &method_call, DBUS_ERROR_FAILED, kErrorMessage));
- EXPECT_EQ(Message::MESSAGE_ERROR, error_response->GetMessageType());
- EXPECT_EQ("MESSAGE_ERROR", error_response->GetMessageTypeAsString());
- // The serial should be copied to the reply serial.
- EXPECT_EQ(kSerial, error_response->GetReplySerial());
- // Error message should be added to the payload.
- MessageReader reader(error_response.get());
- std::string error_message;
- ASSERT_TRUE(reader.PopString(&error_message));
- EXPECT_EQ(kErrorMessage, error_message);
- }
- TEST(MessageTest, GetAndSetHeaders) {
- std::unique_ptr<Response> message(Response::CreateEmpty());
- EXPECT_EQ("", message->GetDestination());
- EXPECT_EQ(ObjectPath(std::string()), message->GetPath());
- EXPECT_EQ("", message->GetInterface());
- EXPECT_EQ("", message->GetMember());
- EXPECT_EQ("", message->GetErrorName());
- EXPECT_EQ("", message->GetSender());
- EXPECT_EQ(0U, message->GetSerial());
- EXPECT_EQ(0U, message->GetReplySerial());
- EXPECT_TRUE(message->SetDestination("org.chromium.destination"));
- EXPECT_TRUE(message->SetPath(ObjectPath("/org/chromium/path")));
- EXPECT_TRUE(message->SetInterface("org.chromium.interface"));
- EXPECT_TRUE(message->SetMember("member"));
- EXPECT_TRUE(message->SetErrorName("org.chromium.error"));
- EXPECT_TRUE(message->SetSender(":1.2"));
- message->SetSerial(123);
- message->SetReplySerial(456);
- EXPECT_EQ("org.chromium.destination", message->GetDestination());
- EXPECT_EQ(ObjectPath("/org/chromium/path"), message->GetPath());
- EXPECT_EQ("org.chromium.interface", message->GetInterface());
- EXPECT_EQ("member", message->GetMember());
- EXPECT_EQ("org.chromium.error", message->GetErrorName());
- EXPECT_EQ(":1.2", message->GetSender());
- EXPECT_EQ(123U, message->GetSerial());
- EXPECT_EQ(456U, message->GetReplySerial());
- }
- TEST(MessageTest, SetInvalidHeaders) {
- std::unique_ptr<Response> message(Response::CreateEmpty());
- EXPECT_EQ("", message->GetDestination());
- EXPECT_EQ(ObjectPath(std::string()), message->GetPath());
- EXPECT_EQ("", message->GetInterface());
- EXPECT_EQ("", message->GetMember());
- EXPECT_EQ("", message->GetErrorName());
- EXPECT_EQ("", message->GetSender());
- // Empty element between periods.
- EXPECT_FALSE(message->SetDestination("org..chromium"));
- // Trailing '/' is only allowed for the root path.
- EXPECT_FALSE(message->SetPath(ObjectPath("/org/chromium/")));
- // Interface name cannot contain '/'.
- EXPECT_FALSE(message->SetInterface("org/chromium/interface"));
- // Member name cannot begin with a digit.
- EXPECT_FALSE(message->SetMember("1member"));
- // Error name cannot begin with a period.
- EXPECT_FALSE(message->SetErrorName(".org.chromium.error"));
- // Disallowed characters.
- EXPECT_FALSE(message->SetSender("?!#*"));
- EXPECT_EQ("", message->GetDestination());
- EXPECT_EQ(ObjectPath(std::string()), message->GetPath());
- EXPECT_EQ("", message->GetInterface());
- EXPECT_EQ("", message->GetMember());
- EXPECT_EQ("", message->GetErrorName());
- EXPECT_EQ("", message->GetSender());
- }
- TEST(MessageTest, ToString_LongString) {
- const std::string kLongString(1000, 'o');
- std::unique_ptr<Response> message(Response::CreateEmpty());
- MessageWriter writer(message.get());
- writer.AppendString(kLongString);
- ASSERT_EQ(
- "message_type: MESSAGE_METHOD_RETURN\n"
- "signature: s\n\n"
- "string \"oooooooooooooooooooooooooooooooooooooooooooooooo"
- "oooooooooooooooooooooooooooooooooooooooooooooooooooo... "
- "(1000 bytes in total)\"\n",
- message->ToString());
- }
- } // namespace dbus
|