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