message_unittest.cc 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727
  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. #include "dbus/message.h"
  5. #include <stddef.h>
  6. #include <stdint.h>
  7. #include <memory>
  8. #include "base/logging.h"
  9. #include "base/posix/eintr_wrapper.h"
  10. #include "dbus/object_path.h"
  11. #include "dbus/test_proto.pb.h"
  12. #include "testing/gtest/include/gtest/gtest.h"
  13. namespace dbus {
  14. // Test that a byte can be properly written and read. We only have this
  15. // test for byte, as repeating this for other basic types is too redundant.
  16. TEST(MessageTest, AppendAndPopByte) {
  17. std::unique_ptr<Response> message(Response::CreateEmpty());
  18. MessageWriter writer(message.get());
  19. writer.AppendByte(123); // The input is 123.
  20. MessageReader reader(message.get());
  21. ASSERT_TRUE(reader.HasMoreData()); // Should have data to read.
  22. ASSERT_EQ(Message::BYTE, reader.GetDataType());
  23. ASSERT_EQ("y", reader.GetDataSignature());
  24. bool bool_value = false;
  25. // Should fail as the type is not bool here.
  26. ASSERT_FALSE(reader.PopBool(&bool_value));
  27. uint8_t byte_value = 0;
  28. ASSERT_TRUE(reader.PopByte(&byte_value));
  29. EXPECT_EQ(123, byte_value); // Should match with the input.
  30. ASSERT_FALSE(reader.HasMoreData()); // Should not have more data to read.
  31. // Try to get another byte. Should fail.
  32. ASSERT_FALSE(reader.PopByte(&byte_value));
  33. }
  34. // Check all basic types can be properly written and read.
  35. TEST(MessageTest, AppendAndPopBasicDataTypes) {
  36. std::unique_ptr<Response> message(Response::CreateEmpty());
  37. MessageWriter writer(message.get());
  38. // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path".
  39. writer.AppendByte(0);
  40. writer.AppendBool(true);
  41. writer.AppendInt16(2);
  42. writer.AppendUint16(3);
  43. writer.AppendInt32(4);
  44. writer.AppendUint32(5);
  45. writer.AppendInt64(6);
  46. writer.AppendUint64(7);
  47. writer.AppendDouble(8.0);
  48. writer.AppendString("string");
  49. writer.AppendObjectPath(ObjectPath("/object/path"));
  50. uint8_t byte_value = 0;
  51. bool bool_value = false;
  52. int16_t int16_value = 0;
  53. uint16_t uint16_value = 0;
  54. int32_t int32_value = 0;
  55. uint32_t uint32_value = 0;
  56. int64_t int64_value = 0;
  57. uint64_t uint64_value = 0;
  58. double double_value = 0;
  59. std::string string_value;
  60. ObjectPath object_path_value;
  61. MessageReader reader(message.get());
  62. ASSERT_TRUE(reader.HasMoreData());
  63. ASSERT_EQ("y", reader.GetDataSignature());
  64. ASSERT_TRUE(reader.PopByte(&byte_value));
  65. ASSERT_EQ("b", reader.GetDataSignature());
  66. ASSERT_TRUE(reader.PopBool(&bool_value));
  67. ASSERT_EQ("n", reader.GetDataSignature());
  68. ASSERT_TRUE(reader.PopInt16(&int16_value));
  69. ASSERT_EQ("q", reader.GetDataSignature());
  70. ASSERT_TRUE(reader.PopUint16(&uint16_value));
  71. ASSERT_EQ("i", reader.GetDataSignature());
  72. ASSERT_TRUE(reader.PopInt32(&int32_value));
  73. ASSERT_EQ("u", reader.GetDataSignature());
  74. ASSERT_TRUE(reader.PopUint32(&uint32_value));
  75. ASSERT_EQ("x", reader.GetDataSignature());
  76. ASSERT_TRUE(reader.PopInt64(&int64_value));
  77. ASSERT_EQ("t", reader.GetDataSignature());
  78. ASSERT_TRUE(reader.PopUint64(&uint64_value));
  79. ASSERT_EQ("d", reader.GetDataSignature());
  80. ASSERT_TRUE(reader.PopDouble(&double_value));
  81. ASSERT_EQ("s", reader.GetDataSignature());
  82. ASSERT_TRUE(reader.PopString(&string_value));
  83. ASSERT_EQ("o", reader.GetDataSignature());
  84. ASSERT_TRUE(reader.PopObjectPath(&object_path_value));
  85. ASSERT_EQ("", reader.GetDataSignature());
  86. ASSERT_FALSE(reader.HasMoreData());
  87. // 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path" should be returned.
  88. EXPECT_EQ(0, byte_value);
  89. EXPECT_EQ(true, bool_value);
  90. EXPECT_EQ(2, int16_value);
  91. EXPECT_EQ(3U, uint16_value);
  92. EXPECT_EQ(4, int32_value);
  93. EXPECT_EQ(5U, uint32_value);
  94. EXPECT_EQ(6, int64_value);
  95. EXPECT_EQ(7U, uint64_value);
  96. EXPECT_DOUBLE_EQ(8.0, double_value);
  97. EXPECT_EQ("string", string_value);
  98. EXPECT_EQ(ObjectPath("/object/path"), object_path_value);
  99. }
  100. // Check all basic types can be properly written and read.
  101. TEST(MessageTest, AppendAndPopFileDescriptor) {
  102. if (!IsDBusTypeUnixFdSupported()) {
  103. LOG(WARNING) << "FD passing is not supported";
  104. return;
  105. }
  106. std::unique_ptr<Response> message(Response::CreateEmpty());
  107. MessageWriter writer(message.get());
  108. // Append stdout.
  109. const int fd_in = 1;
  110. writer.AppendFileDescriptor(fd_in);
  111. base::ScopedFD fd_out;
  112. MessageReader reader(message.get());
  113. ASSERT_TRUE(reader.HasMoreData());
  114. ASSERT_EQ(Message::UNIX_FD, reader.GetDataType());
  115. ASSERT_EQ("h", reader.GetDataSignature());
  116. ASSERT_TRUE(reader.PopFileDescriptor(&fd_out));
  117. ASSERT_FALSE(reader.HasMoreData());
  118. // Stdout should be returned but we cannot check the descriptor
  119. // value because stdout will be dup'd. Instead check st_rdev
  120. // which should be identical.
  121. struct stat sb_stdout;
  122. int status_stdout = HANDLE_EINTR(fstat(fd_in, &sb_stdout));
  123. ASSERT_GE(status_stdout, 0);
  124. struct stat sb_fd;
  125. int status_fd = HANDLE_EINTR(fstat(fd_out.get(), &sb_fd));
  126. ASSERT_GE(status_fd, 0);
  127. EXPECT_EQ(sb_stdout.st_rdev, sb_fd.st_rdev);
  128. }
  129. // Check all variant types can be properly written and read.
  130. TEST(MessageTest, AppendAndPopVariantDataTypes) {
  131. std::unique_ptr<Response> message(Response::CreateEmpty());
  132. MessageWriter writer(message.get());
  133. // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path".
  134. writer.AppendVariantOfByte(0);
  135. writer.AppendVariantOfBool(true);
  136. writer.AppendVariantOfInt16(2);
  137. writer.AppendVariantOfUint16(3);
  138. writer.AppendVariantOfInt32(4);
  139. writer.AppendVariantOfUint32(5);
  140. writer.AppendVariantOfInt64(6);
  141. writer.AppendVariantOfUint64(7);
  142. writer.AppendVariantOfDouble(8.0);
  143. writer.AppendVariantOfString("string");
  144. writer.AppendVariantOfObjectPath(ObjectPath("/object/path"));
  145. uint8_t byte_value = 0;
  146. bool bool_value = false;
  147. int16_t int16_value = 0;
  148. uint16_t uint16_value = 0;
  149. int32_t int32_value = 0;
  150. uint32_t uint32_value = 0;
  151. int64_t int64_value = 0;
  152. uint64_t uint64_value = 0;
  153. double double_value = 0;
  154. std::string string_value;
  155. ObjectPath object_path_value;
  156. MessageReader reader(message.get());
  157. ASSERT_TRUE(reader.HasMoreData());
  158. ASSERT_EQ("v", reader.GetDataSignature());
  159. ASSERT_TRUE(reader.PopVariantOfByte(&byte_value));
  160. ASSERT_EQ("v", reader.GetDataSignature());
  161. ASSERT_TRUE(reader.PopVariantOfBool(&bool_value));
  162. ASSERT_EQ("v", reader.GetDataSignature());
  163. ASSERT_TRUE(reader.PopVariantOfInt16(&int16_value));
  164. ASSERT_EQ("v", reader.GetDataSignature());
  165. ASSERT_TRUE(reader.PopVariantOfUint16(&uint16_value));
  166. ASSERT_EQ("v", reader.GetDataSignature());
  167. ASSERT_TRUE(reader.PopVariantOfInt32(&int32_value));
  168. ASSERT_EQ("v", reader.GetDataSignature());
  169. ASSERT_TRUE(reader.PopVariantOfUint32(&uint32_value));
  170. ASSERT_EQ("v", reader.GetDataSignature());
  171. ASSERT_TRUE(reader.PopVariantOfInt64(&int64_value));
  172. ASSERT_EQ("v", reader.GetDataSignature());
  173. ASSERT_TRUE(reader.PopVariantOfUint64(&uint64_value));
  174. ASSERT_EQ("v", reader.GetDataSignature());
  175. ASSERT_TRUE(reader.PopVariantOfDouble(&double_value));
  176. ASSERT_EQ("v", reader.GetDataSignature());
  177. ASSERT_TRUE(reader.PopVariantOfString(&string_value));
  178. ASSERT_EQ("v", reader.GetDataSignature());
  179. ASSERT_TRUE(reader.PopVariantOfObjectPath(&object_path_value));
  180. ASSERT_EQ("", reader.GetDataSignature());
  181. ASSERT_FALSE(reader.HasMoreData());
  182. // 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path" should be returned.
  183. EXPECT_EQ(0, byte_value);
  184. EXPECT_EQ(true, bool_value);
  185. EXPECT_EQ(2, int16_value);
  186. EXPECT_EQ(3U, uint16_value);
  187. EXPECT_EQ(4, int32_value);
  188. EXPECT_EQ(5U, uint32_value);
  189. EXPECT_EQ(6, int64_value);
  190. EXPECT_EQ(7U, uint64_value);
  191. EXPECT_DOUBLE_EQ(8.0, double_value);
  192. EXPECT_EQ("string", string_value);
  193. EXPECT_EQ(ObjectPath("/object/path"), object_path_value);
  194. }
  195. TEST(MessageTest, ArrayOfBytes) {
  196. std::unique_ptr<Response> message(Response::CreateEmpty());
  197. MessageWriter writer(message.get());
  198. std::vector<uint8_t> bytes;
  199. bytes.push_back(1);
  200. bytes.push_back(2);
  201. bytes.push_back(3);
  202. writer.AppendArrayOfBytes(bytes.data(), bytes.size());
  203. MessageReader reader(message.get());
  204. const uint8_t* output_bytes = nullptr;
  205. size_t length = 0;
  206. ASSERT_EQ("ay", reader.GetDataSignature());
  207. ASSERT_TRUE(reader.PopArrayOfBytes(&output_bytes, &length));
  208. ASSERT_FALSE(reader.HasMoreData());
  209. ASSERT_EQ(3U, length);
  210. EXPECT_EQ(1, output_bytes[0]);
  211. EXPECT_EQ(2, output_bytes[1]);
  212. EXPECT_EQ(3, output_bytes[2]);
  213. }
  214. TEST(MessageTest, ArrayOfInt32s) {
  215. std::unique_ptr<Response> message(Response::CreateEmpty());
  216. MessageWriter writer(message.get());
  217. std::vector<int32_t> int32s;
  218. int32s.push_back(1);
  219. int32s.push_back(2);
  220. int32s.push_back(3);
  221. writer.AppendArrayOfInt32s(int32s.data(), int32s.size());
  222. MessageReader reader(message.get());
  223. const int32_t* output_int32s = nullptr;
  224. size_t length = 0;
  225. ASSERT_EQ("ai", reader.GetDataSignature());
  226. ASSERT_TRUE(reader.PopArrayOfInt32s(&output_int32s, &length));
  227. ASSERT_FALSE(reader.HasMoreData());
  228. ASSERT_EQ(3U, length);
  229. EXPECT_EQ(1, output_int32s[0]);
  230. EXPECT_EQ(2, output_int32s[1]);
  231. EXPECT_EQ(3, output_int32s[2]);
  232. }
  233. TEST(MessageTest, ArrayOfUint32s) {
  234. std::unique_ptr<Response> message(Response::CreateEmpty());
  235. MessageWriter writer(message.get());
  236. std::vector<uint32_t> uint32s;
  237. uint32s.push_back(1);
  238. uint32s.push_back(2);
  239. uint32s.push_back(3);
  240. writer.AppendArrayOfUint32s(uint32s.data(), uint32s.size());
  241. MessageReader reader(message.get());
  242. const uint32_t* output_uint32s = nullptr;
  243. size_t length = 0;
  244. ASSERT_EQ("au", reader.GetDataSignature());
  245. ASSERT_TRUE(reader.PopArrayOfUint32s(&output_uint32s, &length));
  246. ASSERT_FALSE(reader.HasMoreData());
  247. ASSERT_EQ(3U, length);
  248. EXPECT_EQ(1U, output_uint32s[0]);
  249. EXPECT_EQ(2U, output_uint32s[1]);
  250. EXPECT_EQ(3U, output_uint32s[2]);
  251. }
  252. TEST(MessageTest, ArrayOfDoubles) {
  253. std::unique_ptr<Response> message(Response::CreateEmpty());
  254. MessageWriter writer(message.get());
  255. std::vector<double> doubles;
  256. doubles.push_back(0.2);
  257. doubles.push_back(0.5);
  258. doubles.push_back(1);
  259. writer.AppendArrayOfDoubles(doubles.data(), doubles.size());
  260. MessageReader reader(message.get());
  261. const double* output_doubles = nullptr;
  262. size_t length = 0;
  263. ASSERT_EQ("ad", reader.GetDataSignature());
  264. ASSERT_TRUE(reader.PopArrayOfDoubles(&output_doubles, &length));
  265. ASSERT_FALSE(reader.HasMoreData());
  266. ASSERT_EQ(3U, length);
  267. EXPECT_EQ(0.2, output_doubles[0]);
  268. EXPECT_EQ(0.5, output_doubles[1]);
  269. EXPECT_EQ(1, output_doubles[2]);
  270. }
  271. TEST(MessageTest, ArrayOfBytes_Empty) {
  272. std::unique_ptr<Response> message(Response::CreateEmpty());
  273. MessageWriter writer(message.get());
  274. std::vector<uint8_t> bytes;
  275. writer.AppendArrayOfBytes(bytes.data(), bytes.size());
  276. MessageReader reader(message.get());
  277. const uint8_t* output_bytes = nullptr;
  278. size_t length = 0;
  279. ASSERT_EQ("ay", reader.GetDataSignature());
  280. ASSERT_TRUE(reader.PopArrayOfBytes(&output_bytes, &length));
  281. ASSERT_FALSE(reader.HasMoreData());
  282. ASSERT_EQ(0U, length);
  283. EXPECT_EQ(nullptr, output_bytes);
  284. }
  285. TEST(MessageTest, ArrayOfStrings) {
  286. std::unique_ptr<Response> message(Response::CreateEmpty());
  287. MessageWriter writer(message.get());
  288. std::vector<std::string> strings;
  289. strings.push_back("fee");
  290. strings.push_back("fie");
  291. strings.push_back("foe");
  292. strings.push_back("fum");
  293. writer.AppendArrayOfStrings(strings);
  294. MessageReader reader(message.get());
  295. std::vector<std::string> output_strings;
  296. ASSERT_EQ("as", reader.GetDataSignature());
  297. ASSERT_TRUE(reader.PopArrayOfStrings(&output_strings));
  298. ASSERT_FALSE(reader.HasMoreData());
  299. ASSERT_EQ(4U, output_strings.size());
  300. EXPECT_EQ("fee", output_strings[0]);
  301. EXPECT_EQ("fie", output_strings[1]);
  302. EXPECT_EQ("foe", output_strings[2]);
  303. EXPECT_EQ("fum", output_strings[3]);
  304. }
  305. TEST(MessageTest, ArrayOfObjectPaths) {
  306. std::unique_ptr<Response> message(Response::CreateEmpty());
  307. MessageWriter writer(message.get());
  308. std::vector<ObjectPath> object_paths;
  309. object_paths.push_back(ObjectPath("/object/path/1"));
  310. object_paths.push_back(ObjectPath("/object/path/2"));
  311. object_paths.push_back(ObjectPath("/object/path/3"));
  312. writer.AppendArrayOfObjectPaths(object_paths);
  313. MessageReader reader(message.get());
  314. std::vector<ObjectPath> output_object_paths;
  315. ASSERT_EQ("ao", reader.GetDataSignature());
  316. ASSERT_TRUE(reader.PopArrayOfObjectPaths(&output_object_paths));
  317. ASSERT_FALSE(reader.HasMoreData());
  318. ASSERT_EQ(3U, output_object_paths.size());
  319. EXPECT_EQ(ObjectPath("/object/path/1"), output_object_paths[0]);
  320. EXPECT_EQ(ObjectPath("/object/path/2"), output_object_paths[1]);
  321. EXPECT_EQ(ObjectPath("/object/path/3"), output_object_paths[2]);
  322. }
  323. TEST(MessageTest, ProtoBuf) {
  324. std::unique_ptr<Response> message(Response::CreateEmpty());
  325. MessageWriter writer(message.get());
  326. TestProto send_message;
  327. send_message.set_text("testing");
  328. send_message.set_number(123);
  329. writer.AppendProtoAsArrayOfBytes(send_message);
  330. MessageReader reader(message.get());
  331. TestProto receive_message;
  332. ASSERT_EQ("ay", reader.GetDataSignature());
  333. ASSERT_TRUE(reader.PopArrayOfBytesAsProto(&receive_message));
  334. EXPECT_EQ(receive_message.text(), send_message.text());
  335. EXPECT_EQ(receive_message.number(), send_message.number());
  336. }
  337. // Test that an array can be properly written and read. We only have this
  338. // test for array, as repeating this for other container types is too
  339. // redundant.
  340. TEST(MessageTest, OpenArrayAndPopArray) {
  341. std::unique_ptr<Response> message(Response::CreateEmpty());
  342. MessageWriter writer(message.get());
  343. MessageWriter array_writer(nullptr);
  344. writer.OpenArray("s", &array_writer); // Open an array of strings.
  345. array_writer.AppendString("foo");
  346. array_writer.AppendString("bar");
  347. array_writer.AppendString("baz");
  348. writer.CloseContainer(&array_writer);
  349. MessageReader reader(message.get());
  350. ASSERT_EQ(Message::ARRAY, reader.GetDataType());
  351. ASSERT_EQ("as", reader.GetDataSignature());
  352. MessageReader array_reader(nullptr);
  353. ASSERT_TRUE(reader.PopArray(&array_reader));
  354. ASSERT_FALSE(reader.HasMoreData()); // Should not have more data to read.
  355. std::string string_value;
  356. ASSERT_TRUE(array_reader.PopString(&string_value));
  357. EXPECT_EQ("foo", string_value);
  358. ASSERT_TRUE(array_reader.PopString(&string_value));
  359. EXPECT_EQ("bar", string_value);
  360. ASSERT_TRUE(array_reader.PopString(&string_value));
  361. EXPECT_EQ("baz", string_value);
  362. // Should not have more data to read.
  363. ASSERT_FALSE(array_reader.HasMoreData());
  364. }
  365. // Create a complex message using array, struct, variant, dict entry, and
  366. // make sure it can be read properly.
  367. TEST(MessageTest, CreateComplexMessageAndReadIt) {
  368. std::unique_ptr<Response> message(Response::CreateEmpty());
  369. MessageWriter writer(message.get());
  370. {
  371. MessageWriter array_writer(nullptr);
  372. // Open an array of variants.
  373. writer.OpenArray("v", &array_writer);
  374. {
  375. // The first value in the array.
  376. {
  377. MessageWriter variant_writer(nullptr);
  378. // Open a variant of a boolean.
  379. array_writer.OpenVariant("b", &variant_writer);
  380. variant_writer.AppendBool(true);
  381. array_writer.CloseContainer(&variant_writer);
  382. }
  383. // The second value in the array.
  384. {
  385. MessageWriter variant_writer(nullptr);
  386. // Open a variant of a struct that contains a string and an int32_t.
  387. array_writer.OpenVariant("(si)", &variant_writer);
  388. {
  389. MessageWriter struct_writer(nullptr);
  390. variant_writer.OpenStruct(&struct_writer);
  391. struct_writer.AppendString("string");
  392. struct_writer.AppendInt32(123);
  393. variant_writer.CloseContainer(&struct_writer);
  394. }
  395. array_writer.CloseContainer(&variant_writer);
  396. }
  397. // The third value in the array.
  398. {
  399. MessageWriter variant_writer(nullptr);
  400. // Open a variant of an array of string-to-int64_t dict entries.
  401. array_writer.OpenVariant("a{sx}", &variant_writer);
  402. {
  403. // Opens an array of string-to-int64_t dict entries.
  404. MessageWriter dict_array_writer(nullptr);
  405. variant_writer.OpenArray("{sx}", &dict_array_writer);
  406. {
  407. // Opens a string-to-int64_t dict entries.
  408. MessageWriter dict_entry_writer(nullptr);
  409. dict_array_writer.OpenDictEntry(&dict_entry_writer);
  410. dict_entry_writer.AppendString("foo");
  411. dict_entry_writer.AppendInt64(INT64_C(1234567890123456789));
  412. dict_array_writer.CloseContainer(&dict_entry_writer);
  413. }
  414. variant_writer.CloseContainer(&dict_array_writer);
  415. }
  416. array_writer.CloseContainer(&variant_writer);
  417. }
  418. }
  419. writer.CloseContainer(&array_writer);
  420. }
  421. // What we have created looks like this:
  422. EXPECT_EQ(
  423. "message_type: MESSAGE_METHOD_RETURN\n"
  424. "signature: av\n"
  425. "\n"
  426. "array [\n"
  427. " variant bool true\n"
  428. " variant struct {\n"
  429. " string \"string\"\n"
  430. " int32_t 123\n"
  431. " }\n"
  432. " variant array [\n"
  433. " dict entry {\n"
  434. " string \"foo\"\n"
  435. " int64_t 1234567890123456789\n"
  436. " }\n"
  437. " ]\n"
  438. "]\n",
  439. message->ToString());
  440. MessageReader reader(message.get());
  441. ASSERT_EQ("av", reader.GetDataSignature());
  442. MessageReader array_reader(nullptr);
  443. ASSERT_TRUE(reader.PopArray(&array_reader));
  444. // The first value in the array.
  445. bool bool_value = false;
  446. ASSERT_EQ("v", array_reader.GetDataSignature());
  447. ASSERT_TRUE(array_reader.PopVariantOfBool(&bool_value));
  448. EXPECT_EQ(true, bool_value);
  449. // The second value in the array.
  450. {
  451. MessageReader variant_reader(nullptr);
  452. ASSERT_TRUE(array_reader.PopVariant(&variant_reader));
  453. {
  454. MessageReader struct_reader(nullptr);
  455. ASSERT_EQ("(si)", variant_reader.GetDataSignature());
  456. ASSERT_TRUE(variant_reader.PopStruct(&struct_reader));
  457. std::string string_value;
  458. ASSERT_TRUE(struct_reader.PopString(&string_value));
  459. EXPECT_EQ("string", string_value);
  460. int32_t int32_value = 0;
  461. ASSERT_TRUE(struct_reader.PopInt32(&int32_value));
  462. EXPECT_EQ(123, int32_value);
  463. ASSERT_FALSE(struct_reader.HasMoreData());
  464. }
  465. ASSERT_FALSE(variant_reader.HasMoreData());
  466. }
  467. // The third value in the array.
  468. {
  469. MessageReader variant_reader(nullptr);
  470. ASSERT_TRUE(array_reader.PopVariant(&variant_reader));
  471. {
  472. MessageReader dict_array_reader(nullptr);
  473. ASSERT_EQ("a{sx}", variant_reader.GetDataSignature());
  474. ASSERT_TRUE(variant_reader.PopArray(&dict_array_reader));
  475. {
  476. MessageReader dict_entry_reader(nullptr);
  477. ASSERT_TRUE(dict_array_reader.PopDictEntry(&dict_entry_reader));
  478. std::string string_value;
  479. ASSERT_TRUE(dict_entry_reader.PopString(&string_value));
  480. EXPECT_EQ("foo", string_value);
  481. int64_t int64_value = 0;
  482. ASSERT_TRUE(dict_entry_reader.PopInt64(&int64_value));
  483. EXPECT_EQ(INT64_C(1234567890123456789), int64_value);
  484. }
  485. ASSERT_FALSE(dict_array_reader.HasMoreData());
  486. }
  487. ASSERT_FALSE(variant_reader.HasMoreData());
  488. }
  489. ASSERT_FALSE(array_reader.HasMoreData());
  490. ASSERT_FALSE(reader.HasMoreData());
  491. }
  492. TEST(MessageTest, MethodCall) {
  493. MethodCall method_call("com.example.Interface", "SomeMethod");
  494. EXPECT_NE(nullptr, method_call.raw_message());
  495. EXPECT_EQ(Message::MESSAGE_METHOD_CALL, method_call.GetMessageType());
  496. EXPECT_EQ("MESSAGE_METHOD_CALL", method_call.GetMessageTypeAsString());
  497. method_call.SetDestination("com.example.Service");
  498. method_call.SetPath(ObjectPath("/com/example/Object"));
  499. MessageWriter writer(&method_call);
  500. writer.AppendString("payload");
  501. EXPECT_EQ(
  502. "message_type: MESSAGE_METHOD_CALL\n"
  503. "destination: com.example.Service\n"
  504. "path: /com/example/Object\n"
  505. "interface: com.example.Interface\n"
  506. "member: SomeMethod\n"
  507. "signature: s\n"
  508. "\n"
  509. "string \"payload\"\n",
  510. method_call.ToString());
  511. }
  512. TEST(MessageTest, MethodCall_FromRawMessage) {
  513. DBusMessage* raw_message = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
  514. dbus_message_set_interface(raw_message, "com.example.Interface");
  515. dbus_message_set_member(raw_message, "SomeMethod");
  516. std::unique_ptr<MethodCall> method_call(
  517. MethodCall::FromRawMessage(raw_message));
  518. EXPECT_EQ("com.example.Interface", method_call->GetInterface());
  519. EXPECT_EQ("SomeMethod", method_call->GetMember());
  520. }
  521. TEST(MessageTest, Signal) {
  522. Signal signal("com.example.Interface", "SomeSignal");
  523. EXPECT_NE(nullptr, signal.raw_message());
  524. EXPECT_EQ(Message::MESSAGE_SIGNAL, signal.GetMessageType());
  525. EXPECT_EQ("MESSAGE_SIGNAL", signal.GetMessageTypeAsString());
  526. signal.SetPath(ObjectPath("/com/example/Object"));
  527. MessageWriter writer(&signal);
  528. writer.AppendString("payload");
  529. EXPECT_EQ(
  530. "message_type: MESSAGE_SIGNAL\n"
  531. "path: /com/example/Object\n"
  532. "interface: com.example.Interface\n"
  533. "member: SomeSignal\n"
  534. "signature: s\n"
  535. "\n"
  536. "string \"payload\"\n",
  537. signal.ToString());
  538. }
  539. TEST(MessageTest, Signal_FromRawMessage) {
  540. DBusMessage* raw_message = dbus_message_new(DBUS_MESSAGE_TYPE_SIGNAL);
  541. dbus_message_set_interface(raw_message, "com.example.Interface");
  542. dbus_message_set_member(raw_message, "SomeSignal");
  543. std::unique_ptr<Signal> signal(Signal::FromRawMessage(raw_message));
  544. EXPECT_EQ("com.example.Interface", signal->GetInterface());
  545. EXPECT_EQ("SomeSignal", signal->GetMember());
  546. }
  547. TEST(MessageTest, Response) {
  548. std::unique_ptr<Response> response(Response::CreateEmpty());
  549. EXPECT_TRUE(response->raw_message());
  550. EXPECT_EQ(Message::MESSAGE_METHOD_RETURN, response->GetMessageType());
  551. EXPECT_EQ("MESSAGE_METHOD_RETURN", response->GetMessageTypeAsString());
  552. }
  553. TEST(MessageTest, Response_FromMethodCall) {
  554. const uint32_t kSerial = 123;
  555. MethodCall method_call("com.example.Interface", "SomeMethod");
  556. method_call.SetSerial(kSerial);
  557. std::unique_ptr<Response> response(Response::FromMethodCall(&method_call));
  558. EXPECT_EQ(Message::MESSAGE_METHOD_RETURN, response->GetMessageType());
  559. EXPECT_EQ("MESSAGE_METHOD_RETURN", response->GetMessageTypeAsString());
  560. // The serial should be copied to the reply serial.
  561. EXPECT_EQ(kSerial, response->GetReplySerial());
  562. }
  563. TEST(MessageTest, ErrorResponse_FromMethodCall) {
  564. const uint32_t kSerial = 123;
  565. const char kErrorMessage[] = "error message";
  566. MethodCall method_call("com.example.Interface", "SomeMethod");
  567. method_call.SetSerial(kSerial);
  568. std::unique_ptr<ErrorResponse> error_response(ErrorResponse::FromMethodCall(
  569. &method_call, DBUS_ERROR_FAILED, kErrorMessage));
  570. EXPECT_EQ(Message::MESSAGE_ERROR, error_response->GetMessageType());
  571. EXPECT_EQ("MESSAGE_ERROR", error_response->GetMessageTypeAsString());
  572. // The serial should be copied to the reply serial.
  573. EXPECT_EQ(kSerial, error_response->GetReplySerial());
  574. // Error message should be added to the payload.
  575. MessageReader reader(error_response.get());
  576. std::string error_message;
  577. ASSERT_TRUE(reader.PopString(&error_message));
  578. EXPECT_EQ(kErrorMessage, error_message);
  579. }
  580. TEST(MessageTest, GetAndSetHeaders) {
  581. std::unique_ptr<Response> message(Response::CreateEmpty());
  582. EXPECT_EQ("", message->GetDestination());
  583. EXPECT_EQ(ObjectPath(std::string()), message->GetPath());
  584. EXPECT_EQ("", message->GetInterface());
  585. EXPECT_EQ("", message->GetMember());
  586. EXPECT_EQ("", message->GetErrorName());
  587. EXPECT_EQ("", message->GetSender());
  588. EXPECT_EQ(0U, message->GetSerial());
  589. EXPECT_EQ(0U, message->GetReplySerial());
  590. EXPECT_TRUE(message->SetDestination("org.chromium.destination"));
  591. EXPECT_TRUE(message->SetPath(ObjectPath("/org/chromium/path")));
  592. EXPECT_TRUE(message->SetInterface("org.chromium.interface"));
  593. EXPECT_TRUE(message->SetMember("member"));
  594. EXPECT_TRUE(message->SetErrorName("org.chromium.error"));
  595. EXPECT_TRUE(message->SetSender(":1.2"));
  596. message->SetSerial(123);
  597. message->SetReplySerial(456);
  598. EXPECT_EQ("org.chromium.destination", message->GetDestination());
  599. EXPECT_EQ(ObjectPath("/org/chromium/path"), message->GetPath());
  600. EXPECT_EQ("org.chromium.interface", message->GetInterface());
  601. EXPECT_EQ("member", message->GetMember());
  602. EXPECT_EQ("org.chromium.error", message->GetErrorName());
  603. EXPECT_EQ(":1.2", message->GetSender());
  604. EXPECT_EQ(123U, message->GetSerial());
  605. EXPECT_EQ(456U, message->GetReplySerial());
  606. }
  607. TEST(MessageTest, SetInvalidHeaders) {
  608. std::unique_ptr<Response> message(Response::CreateEmpty());
  609. EXPECT_EQ("", message->GetDestination());
  610. EXPECT_EQ(ObjectPath(std::string()), message->GetPath());
  611. EXPECT_EQ("", message->GetInterface());
  612. EXPECT_EQ("", message->GetMember());
  613. EXPECT_EQ("", message->GetErrorName());
  614. EXPECT_EQ("", message->GetSender());
  615. // Empty element between periods.
  616. EXPECT_FALSE(message->SetDestination("org..chromium"));
  617. // Trailing '/' is only allowed for the root path.
  618. EXPECT_FALSE(message->SetPath(ObjectPath("/org/chromium/")));
  619. // Interface name cannot contain '/'.
  620. EXPECT_FALSE(message->SetInterface("org/chromium/interface"));
  621. // Member name cannot begin with a digit.
  622. EXPECT_FALSE(message->SetMember("1member"));
  623. // Error name cannot begin with a period.
  624. EXPECT_FALSE(message->SetErrorName(".org.chromium.error"));
  625. // Disallowed characters.
  626. EXPECT_FALSE(message->SetSender("?!#*"));
  627. EXPECT_EQ("", message->GetDestination());
  628. EXPECT_EQ(ObjectPath(std::string()), message->GetPath());
  629. EXPECT_EQ("", message->GetInterface());
  630. EXPECT_EQ("", message->GetMember());
  631. EXPECT_EQ("", message->GetErrorName());
  632. EXPECT_EQ("", message->GetSender());
  633. }
  634. TEST(MessageTest, ToString_LongString) {
  635. const std::string kLongString(1000, 'o');
  636. std::unique_ptr<Response> message(Response::CreateEmpty());
  637. MessageWriter writer(message.get());
  638. writer.AppendString(kLongString);
  639. ASSERT_EQ(
  640. "message_type: MESSAGE_METHOD_RETURN\n"
  641. "signature: s\n\n"
  642. "string \"oooooooooooooooooooooooooooooooooooooooooooooooo"
  643. "oooooooooooooooooooooooooooooooooooooooooooooooooooo... "
  644. "(1000 bytes in total)\"\n",
  645. message->ToString());
  646. }
  647. } // namespace dbus