blob: 2f2dc33acc684f554e71a3e706f8e4a987e5c9ff [file] [log] [blame] [edit]
// Copyright 2012 The Chromium Authors
// 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