OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2017 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 | |
5 #include "build/build_config.h" | |
6 | |
7 #if defined(OS_NACL_NONSFI) | |
8 static_assert(false, | |
9 "ipc_message_repeated_field_utils is not able to work with " | |
10 "nacl_nonsfi configuration."); | |
11 #endif | |
12 | |
13 #include "ipc/ipc_message_repeated_field_utils.h" | |
14 | |
15 #include <initializer_list> | |
16 | |
17 #include "ipc/test_proto.pb.h" | |
18 #include "ipc/ipc_message.h" | |
19 #include "ipc/ipc_message_utils.h" | |
20 #include "testing/gtest/include/gtest/gtest.h" | |
21 | |
22 namespace IPC { | |
23 | |
24 template <> | |
25 struct ParamTraits<ipc_message_utils_test::TestMessage1> { | |
26 typedef ipc_message_utils_test::TestMessage1 param_type; | |
27 static void GetSize(base::PickleSizer* sizer, const param_type& p) { | |
28 GetParamSize(sizer, p.number()); | |
29 } | |
30 static void Write(base::Pickle* m, const param_type& p) { | |
31 WriteParam(m, p.number()); | |
32 } | |
33 static bool Read(const base::Pickle* m, | |
34 base::PickleIterator* iter, | |
35 param_type* r) { | |
36 int number; | |
37 if (!iter->ReadInt(&number)) | |
38 return false; | |
39 r->set_number(number); | |
40 return true; | |
41 } | |
42 }; | |
43 | |
44 template <> | |
45 struct ParamTraits<ipc_message_utils_test::TestMessage2> { | |
46 typedef ipc_message_utils_test::TestMessage2 param_type; | |
47 static void GetSize(base::PickleSizer* sizer, const param_type& p) { | |
48 GetParamSize(sizer, p.numbers()); | |
49 GetParamSize(sizer, p.strings()); | |
50 GetParamSize(sizer, p.messages()); | |
51 } | |
52 static void Write(base::Pickle* m, const param_type& p) { | |
53 WriteParam(m, p.numbers()); | |
54 WriteParam(m, p.strings()); | |
55 WriteParam(m, p.messages()); | |
56 } | |
57 static bool Read(const base::Pickle* m, | |
58 base::PickleIterator* iter, | |
59 param_type* r) { | |
60 return ReadParam(m, iter, r->mutable_numbers()) && | |
61 ReadParam(m, iter, r->mutable_strings()) && | |
62 ReadParam(m, iter, r->mutable_messages()); | |
63 } | |
64 }; | |
65 | |
66 namespace { | |
67 | |
68 template <class P1, class P2> | |
69 void AssertEqual(const P1& left, const P2& right) { | |
70 ASSERT_EQ(left, right); | |
71 } | |
72 | |
73 template<> | |
74 void AssertEqual(const int& left, | |
75 const ipc_message_utils_test::TestMessage1& right) { | |
76 ASSERT_EQ(left, right.number()); | |
77 } | |
78 | |
79 template <template<class> class RepeatedFieldLike, class P1, class P2> | |
80 void AssertRepeatedFieldEquals(std::initializer_list<P1> expected, | |
81 const RepeatedFieldLike<P2>& fields) { | |
82 ASSERT_EQ(static_cast<int>(expected.size()), fields.size()); | |
83 auto it = expected.begin(); | |
84 int i = 0; | |
85 for (; it != expected.end(); it++, i++) { | |
86 AssertEqual(*it, fields.Get(i)); | |
87 } | |
88 } | |
89 | |
90 TEST(IPCMessageRepeatedFieldUtilsTest, RepeatedFieldShouldBeSerialized) { | |
91 ipc_message_utils_test::TestMessage2 message; | |
92 message.add_numbers(1); | |
93 message.add_numbers(100); | |
94 message.add_strings("abc"); | |
95 message.add_strings("def"); | |
96 { | |
97 ipc_message_utils_test::TestMessage1 message1; | |
98 message1.set_number(1000); | |
99 *message.add_messages() = message1; | |
dcheng
2017/07/13 22:25:07
This works, but I feel like it might be clearer to
Hzj_jie
2017/07/14 00:25:09
Done.
| |
100 message1.set_number(10000); | |
101 *message.add_messages() = message1; | |
102 } | |
103 | |
104 base::Pickle pickle; | |
105 IPC::WriteParam(&pickle, message); | |
106 | |
107 base::PickleSizer sizer; | |
108 IPC::GetParamSize(&sizer, message); | |
109 | |
110 ASSERT_EQ(sizer.payload_size(), pickle.payload_size()); | |
111 | |
112 base::PickleIterator iter(pickle); | |
113 ipc_message_utils_test::TestMessage2 output; | |
114 ASSERT_TRUE(IPC::ReadParam(&pickle, &iter, &output)); | |
115 | |
116 AssertRepeatedFieldEquals({1, 100}, output.numbers()); | |
117 AssertRepeatedFieldEquals({"abc", "def"}, output.strings()); | |
118 AssertRepeatedFieldEquals({1000, 10000}, output.messages()); | |
119 } | |
120 | |
121 TEST(IPCMessageRepeatedFieldUtilsTest, PartialEmptyRepeatedFieldShouldBeSerializ ed) { | |
dcheng
2017/07/13 22:25:07
Nit: git cl format to fix formatting
Hzj_jie
2017/07/14 00:25:09
Done.
| |
122 ipc_message_utils_test::TestMessage2 message; | |
123 message.add_numbers(1); | |
124 message.add_numbers(100); | |
125 { | |
126 ipc_message_utils_test::TestMessage1 message1; | |
127 message1.set_number(1000); | |
128 *message.add_messages() = message1; | |
129 message1.set_number(10000); | |
130 *message.add_messages() = message1; | |
131 } | |
132 | |
133 base::Pickle pickle; | |
134 IPC::WriteParam(&pickle, message); | |
135 | |
136 base::PickleSizer sizer; | |
137 IPC::GetParamSize(&sizer, message); | |
138 | |
139 ASSERT_EQ(sizer.payload_size(), pickle.payload_size()); | |
140 | |
141 base::PickleIterator iter(pickle); | |
142 ipc_message_utils_test::TestMessage2 output; | |
143 ASSERT_TRUE(IPC::ReadParam(&pickle, &iter, &output)); | |
144 | |
145 AssertRepeatedFieldEquals({1, 100}, output.numbers()); | |
146 ASSERT_EQ(0, output.strings_size()); | |
147 AssertRepeatedFieldEquals({1000, 10000}, output.messages()); | |
148 } | |
149 | |
150 TEST(IPCMessageRepeatedFieldUtilsTest, EmptyRepeatedFieldShouldBeSerialized) { | |
151 ipc_message_utils_test::TestMessage2 message; | |
152 | |
153 base::Pickle pickle; | |
154 IPC::WriteParam(&pickle, message); | |
155 | |
156 base::PickleSizer sizer; | |
157 IPC::GetParamSize(&sizer, message); | |
158 | |
159 ASSERT_EQ(sizer.payload_size(), pickle.payload_size()); | |
160 | |
161 base::PickleIterator iter(pickle); | |
162 ipc_message_utils_test::TestMessage2 output; | |
163 ASSERT_TRUE(IPC::ReadParam(&pickle, &iter, &output)); | |
164 | |
165 ASSERT_EQ(0, output.numbers_size()); | |
166 ASSERT_EQ(0, output.strings_size()); | |
167 ASSERT_EQ(0, output.messages_size()); | |
168 } | |
169 | |
170 TEST(IPCMessageRepeatedFieldUtilsTest, | |
171 InvalidPickleShouldNotCrashRepeatedFieldDeserialization) { | |
172 base::Pickle pickle; | |
173 IPC::WriteParam(&pickle, INT_MAX); | |
174 IPC::WriteParam(&pickle, 0); | |
175 IPC::WriteParam(&pickle, INT_MAX); | |
176 IPC::WriteParam(&pickle, std::string()); | |
177 IPC::WriteParam(&pickle, 0); | |
178 | |
179 base::PickleIterator iter(pickle); | |
180 ipc_message_utils_test::TestMessage2 output; | |
181 ASSERT_FALSE(IPC::ReadParam(&pickle, &iter, &output)); | |
182 } | |
183 | |
184 // This test needs ~20 seconds in Debug mode, or ~4 seconds in Release mode. | |
185 // See http://crbug.com/741866 for details. | |
186 TEST(IPCMessageRepeatedFieldUtilsTest, | |
187 DISALBED_InvalidPickleShouldNotCrashRepeatedFieldDeserialization2) { | |
dcheng
2017/07/13 22:25:07
Nit: DISABLED
Hzj_jie
2017/07/14 00:25:09
Done.
I totally failed to write two "DISABLED" tes
| |
188 base::Pickle pickle; | |
189 IPC::WriteParam(&pickle, 256 * 1024 * 1024); | |
190 IPC::WriteParam(&pickle, 0); | |
191 IPC::WriteParam(&pickle, INT_MAX); | |
192 IPC::WriteParam(&pickle, std::string()); | |
193 IPC::WriteParam(&pickle, 0); | |
194 | |
195 base::PickleIterator iter(pickle); | |
196 ipc_message_utils_test::TestMessage2 output; | |
197 ASSERT_FALSE(IPC::ReadParam(&pickle, &iter, &output)); | |
198 } | |
199 | |
200 } // namespace | |
201 | |
202 } // namespace IPC | |
OLD | NEW |