Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / protobuf-javalite / 885b612f74f133678bf82808c589331e4c59dad9 / . / src / google / protobuf / map_test_util.cc
blob: 1713e3736470c736d5dbc91b354175b48caecd74 [file] [log] [blame]
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]1// Protocol Buffers - Google's data interchange format
2// Copyright 2008 Google Inc. All rights reserved.
3// https://developers.google.com/protocol-buffers/
4//
5// Redistribution and use in source and binary forms, with or without
6// modification, are permitted provided that the following conditions are
7// met:
8//
9// * Redistributions of source code must retain the above copyright
10// notice, this list of conditions and the following disclaimer.
11// * Redistributions in binary form must reproduce the above
12// copyright notice, this list of conditions and the following disclaimer
13// in the documentation and/or other materials provided with the
14// distribution.
15// * Neither the name of Google Inc. nor the names of its
16// contributors may be used to endorse or promote products derived from
17// this software without specific prior written permission.
18//
19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31#include <google/protobuf/map_test_util.h>
Jisi Liu885b6122015-02-28 14:51:22 -0800[diff] [blame^]32#include <google/protobuf/map_test_util_impl.h>
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]33#include <google/protobuf/descriptor.h>
34#include <google/protobuf/message.h>
35
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]36namespace google {
37namespace protobuf {
38
39void MapTestUtil::SetMapFields(unittest::TestMap* message) {
Jisi Liu885b6122015-02-28 14:51:22 -0800[diff] [blame^]40 MapTestUtilImpl::SetMapFields<unittest::MapEnum, unittest::MAP_ENUM_BAR,
41 unittest::MAP_ENUM_BAZ>(message);
42}
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]43
Jisi Liu885b6122015-02-28 14:51:22 -0800[diff] [blame^]44void MapTestUtil::SetArenaMapFields(unittest::TestArenaMap* message) {
45 MapTestUtilImpl::SetArenaMapFields<unittest::MapEnum, unittest::MAP_ENUM_BAR,
46 unittest::MAP_ENUM_BAZ>(message);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]47}
48
49void MapTestUtil::SetMapFieldsInitialized(unittest::TestMap* message) {
Jisi Liu885b6122015-02-28 14:51:22 -0800[diff] [blame^]50 MapTestUtilImpl::SetMapFieldsInitialized(message);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]51}
52
53void MapTestUtil::ModifyMapFields(unittest::TestMap* message) {
Jisi Liu885b6122015-02-28 14:51:22 -0800[diff] [blame^]54 MapTestUtilImpl::ModifyMapFields<unittest::MapEnum, unittest::MAP_ENUM_FOO>(
55 message);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]56}
57
58void MapTestUtil::ExpectClear(const unittest::TestMap& message) {
Jisi Liu885b6122015-02-28 14:51:22 -0800[diff] [blame^]59 MapTestUtilImpl::ExpectClear(message);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]60}
61
62void MapTestUtil::ExpectMapFieldsSet(const unittest::TestMap& message) {
Jisi Liu885b6122015-02-28 14:51:22 -0800[diff] [blame^]63 MapTestUtilImpl::ExpectMapFieldsSet<unittest::MapEnum, unittest::MAP_ENUM_BAR,
64 unittest::MAP_ENUM_BAZ>(message);
65}
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]66
Jisi Liu885b6122015-02-28 14:51:22 -0800[diff] [blame^]67void MapTestUtil::ExpectArenaMapFieldsSet(
68 const unittest::TestArenaMap& message) {
69 MapTestUtilImpl::ExpectArenaMapFieldsSet<
70 unittest::MapEnum, unittest::MAP_ENUM_BAR, unittest::MAP_ENUM_BAZ>(
71 message);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]72}
73
74void MapTestUtil::ExpectMapFieldsSetInitialized(
75 const unittest::TestMap& message) {
Jisi Liu885b6122015-02-28 14:51:22 -0800[diff] [blame^]76 MapTestUtilImpl::ExpectMapFieldsSetInitialized<unittest::MapEnum,
77 unittest::MAP_ENUM_FOO>(
78 message);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]79}
80
81void MapTestUtil::ExpectMapFieldsModified(
82 const unittest::TestMap& message) {
Jisi Liu885b6122015-02-28 14:51:22 -0800[diff] [blame^]83 MapTestUtilImpl::ExpectMapFieldsModified<
84 unittest::MapEnum, unittest::MAP_ENUM_BAR, unittest::MAP_ENUM_FOO>(
85 message);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]86}
87
88void MapTestUtil::ExpectMapsSize(
89 const unittest::TestMap& message, int size) {
90 const Descriptor* descriptor = message.GetDescriptor();
91
92 EXPECT_EQ(size, message.GetReflection()->FieldSize(
93 message, descriptor->FindFieldByName("map_int32_int32")));
94 EXPECT_EQ(size, message.GetReflection()->FieldSize(
95 message, descriptor->FindFieldByName("map_int64_int64")));
96 EXPECT_EQ(size, message.GetReflection()->FieldSize(
97 message, descriptor->FindFieldByName("map_uint32_uint32")));
98 EXPECT_EQ(size, message.GetReflection()->FieldSize(
99 message, descriptor->FindFieldByName("map_uint64_uint64")));
100 EXPECT_EQ(size, message.GetReflection()->FieldSize(
101 message, descriptor->FindFieldByName("map_sint32_sint32")));
102 EXPECT_EQ(size, message.GetReflection()->FieldSize(
103 message, descriptor->FindFieldByName("map_sint64_sint64")));
104 EXPECT_EQ(size, message.GetReflection()->FieldSize(
105 message, descriptor->FindFieldByName("map_fixed32_fixed32")));
106 EXPECT_EQ(size, message.GetReflection()->FieldSize(
107 message, descriptor->FindFieldByName("map_fixed64_fixed64")));
108 EXPECT_EQ(size, message.GetReflection()->FieldSize(
109 message, descriptor->FindFieldByName("map_sfixed32_sfixed32")));
110 EXPECT_EQ(size, message.GetReflection()->FieldSize(
111 message, descriptor->FindFieldByName("map_sfixed64_sfixed64")));
112 EXPECT_EQ(size, message.GetReflection()->FieldSize(
113 message, descriptor->FindFieldByName("map_int32_float")));
114 EXPECT_EQ(size, message.GetReflection()->FieldSize(
115 message, descriptor->FindFieldByName("map_int32_double")));
116 EXPECT_EQ(size, message.GetReflection()->FieldSize(
117 message, descriptor->FindFieldByName("map_bool_bool")));
118 EXPECT_EQ(size, message.GetReflection()->FieldSize(
119 message, descriptor->FindFieldByName("map_string_string")));
120 EXPECT_EQ(size, message.GetReflection()->FieldSize(
121 message, descriptor->FindFieldByName("map_int32_bytes")));
122 EXPECT_EQ(size, message.GetReflection()->FieldSize(
123 message, descriptor->FindFieldByName("map_int32_foreign_message")));
124}
125
126std::vector<const Message*> MapTestUtil::GetMapEntries(
127 const unittest::TestMap& message, int index) {
128 const Descriptor* descriptor = message.GetDescriptor();
129 std::vector<const Message*> result;
130
131 result.push_back(&message.GetReflection()->GetRepeatedMessage(
132 message, descriptor->FindFieldByName("map_int32_int32"), index));
133 result.push_back(&message.GetReflection()->GetRepeatedMessage(
134 message, descriptor->FindFieldByName("map_int64_int64"), index));
135 result.push_back(&message.GetReflection()->GetRepeatedMessage(
136 message, descriptor->FindFieldByName("map_uint32_uint32"), index));
137 result.push_back(&message.GetReflection()->GetRepeatedMessage(
138 message, descriptor->FindFieldByName("map_uint64_uint64"), index));
139 result.push_back(&message.GetReflection()->GetRepeatedMessage(
140 message, descriptor->FindFieldByName("map_sint32_sint32"), index));
141 result.push_back(&message.GetReflection()->GetRepeatedMessage(
142 message, descriptor->FindFieldByName("map_sint64_sint64"), index));
143 result.push_back(&message.GetReflection()->GetRepeatedMessage(
144 message, descriptor->FindFieldByName("map_fixed32_fixed32"), index));
145 result.push_back(&message.GetReflection()->GetRepeatedMessage(
146 message, descriptor->FindFieldByName("map_fixed64_fixed64"), index));
147 result.push_back(&message.GetReflection()->GetRepeatedMessage(
148 message, descriptor->FindFieldByName("map_sfixed32_sfixed32"), index));
149 result.push_back(&message.GetReflection()->GetRepeatedMessage(
150 message, descriptor->FindFieldByName("map_sfixed64_sfixed64"), index));
151 result.push_back(&message.GetReflection()->GetRepeatedMessage(
152 message, descriptor->FindFieldByName("map_int32_float"), index));
153 result.push_back(&message.GetReflection()->GetRepeatedMessage(
154 message, descriptor->FindFieldByName("map_int32_double"), index));
155 result.push_back(&message.GetReflection()->GetRepeatedMessage(
156 message, descriptor->FindFieldByName("map_bool_bool"), index));
157 result.push_back(&message.GetReflection()->GetRepeatedMessage(
158 message, descriptor->FindFieldByName("map_string_string"), index));
159 result.push_back(&message.GetReflection()->GetRepeatedMessage(
160 message, descriptor->FindFieldByName("map_int32_bytes"), index));
161 result.push_back(&message.GetReflection()->GetRepeatedMessage(
162 message, descriptor->FindFieldByName("map_int32_enum"), index));
163 result.push_back(&message.GetReflection()->GetRepeatedMessage(
164 message, descriptor->FindFieldByName("map_int32_foreign_message"), index));
165
166 return result;
167}
168
169std::vector<const Message*> MapTestUtil::GetMapEntriesFromRelease(
170 unittest::TestMap* message) {
171 const Descriptor* descriptor = message->GetDescriptor();
172 std::vector<const Message*> result;
173
174 result.push_back(message->GetReflection()->ReleaseLast(
175 message, descriptor->FindFieldByName("map_int32_int32")));
176 result.push_back(message->GetReflection()->ReleaseLast(
177 message, descriptor->FindFieldByName("map_int64_int64")));
178 result.push_back(message->GetReflection()->ReleaseLast(
179 message, descriptor->FindFieldByName("map_uint32_uint32")));
180 result.push_back(message->GetReflection()->ReleaseLast(
181 message, descriptor->FindFieldByName("map_uint64_uint64")));
182 result.push_back(message->GetReflection()->ReleaseLast(
183 message, descriptor->FindFieldByName("map_sint32_sint32")));
184 result.push_back(message->GetReflection()->ReleaseLast(
185 message, descriptor->FindFieldByName("map_sint64_sint64")));
186 result.push_back(message->GetReflection()->ReleaseLast(
187 message, descriptor->FindFieldByName("map_fixed32_fixed32")));
188 result.push_back(message->GetReflection()->ReleaseLast(
189 message, descriptor->FindFieldByName("map_fixed64_fixed64")));
190 result.push_back(message->GetReflection()->ReleaseLast(
191 message, descriptor->FindFieldByName("map_sfixed32_sfixed32")));
192 result.push_back(message->GetReflection()->ReleaseLast(
193 message, descriptor->FindFieldByName("map_sfixed64_sfixed64")));
194 result.push_back(message->GetReflection()->ReleaseLast(
195 message, descriptor->FindFieldByName("map_int32_float")));
196 result.push_back(message->GetReflection()->ReleaseLast(
197 message, descriptor->FindFieldByName("map_int32_double")));
198 result.push_back(message->GetReflection()->ReleaseLast(
199 message, descriptor->FindFieldByName("map_bool_bool")));
200 result.push_back(message->GetReflection()->ReleaseLast(
201 message, descriptor->FindFieldByName("map_string_string")));
202 result.push_back(message->GetReflection()->ReleaseLast(
203 message, descriptor->FindFieldByName("map_int32_bytes")));
204 result.push_back(message->GetReflection()->ReleaseLast(
205 message, descriptor->FindFieldByName("map_int32_enum")));
206 result.push_back(message->GetReflection()->ReleaseLast(
207 message, descriptor->FindFieldByName("map_int32_foreign_message")));
208
209 return result;
210}
211
212MapTestUtil::MapReflectionTester::MapReflectionTester(
213 const Descriptor* base_descriptor)
214 : base_descriptor_(base_descriptor) {
215 const DescriptorPool* pool = base_descriptor->file()->pool();
216
217 map_enum_foo_ = pool->FindEnumValueByName("protobuf_unittest.MAP_ENUM_FOO");
218 map_enum_bar_ = pool->FindEnumValueByName("protobuf_unittest.MAP_ENUM_BAR");
219 map_enum_baz_ = pool->FindEnumValueByName("protobuf_unittest.MAP_ENUM_BAZ");
220
221 foreign_c_ = pool->FindFieldByName(
222 "protobuf_unittest.ForeignMessage.c");
223 map_int32_int32_key_ = pool->FindFieldByName(
224 "protobuf_unittest.TestMap.MapInt32Int32Entry.key");
225 map_int32_int32_val_ = pool->FindFieldByName(
226 "protobuf_unittest.TestMap.MapInt32Int32Entry.value");
227 map_int64_int64_key_ = pool->FindFieldByName(
228 "protobuf_unittest.TestMap.MapInt64Int64Entry.key");
229 map_int64_int64_val_ = pool->FindFieldByName(
230 "protobuf_unittest.TestMap.MapInt64Int64Entry.value");
231 map_uint32_uint32_key_ = pool->FindFieldByName(
232 "protobuf_unittest.TestMap.MapUint32Uint32Entry.key");
233 map_uint32_uint32_val_ = pool->FindFieldByName(
234 "protobuf_unittest.TestMap.MapUint32Uint32Entry.value");
235 map_uint64_uint64_key_ = pool->FindFieldByName(
236 "protobuf_unittest.TestMap.MapUint64Uint64Entry.key");
237 map_uint64_uint64_val_ = pool->FindFieldByName(
238 "protobuf_unittest.TestMap.MapUint64Uint64Entry.value");
239 map_sint32_sint32_key_ = pool->FindFieldByName(
240 "protobuf_unittest.TestMap.MapSint32Sint32Entry.key");
241 map_sint32_sint32_val_ = pool->FindFieldByName(
242 "protobuf_unittest.TestMap.MapSint32Sint32Entry.value");
243 map_sint64_sint64_key_ = pool->FindFieldByName(
244 "protobuf_unittest.TestMap.MapSint64Sint64Entry.key");
245 map_sint64_sint64_val_ = pool->FindFieldByName(
246 "protobuf_unittest.TestMap.MapSint64Sint64Entry.value");
247 map_fixed32_fixed32_key_ = pool->FindFieldByName(
248 "protobuf_unittest.TestMap.MapFixed32Fixed32Entry.key");
249 map_fixed32_fixed32_val_ = pool->FindFieldByName(
250 "protobuf_unittest.TestMap.MapFixed32Fixed32Entry.value");
251 map_fixed64_fixed64_key_ = pool->FindFieldByName(
252 "protobuf_unittest.TestMap.MapFixed64Fixed64Entry.key");
253 map_fixed64_fixed64_val_ = pool->FindFieldByName(
254 "protobuf_unittest.TestMap.MapFixed64Fixed64Entry.value");
255 map_sfixed32_sfixed32_key_ = pool->FindFieldByName(
256 "protobuf_unittest.TestMap.MapSfixed32Sfixed32Entry.key");
257 map_sfixed32_sfixed32_val_ = pool->FindFieldByName(
258 "protobuf_unittest.TestMap.MapSfixed32Sfixed32Entry.value");
259 map_sfixed64_sfixed64_key_ = pool->FindFieldByName(
260 "protobuf_unittest.TestMap.MapSfixed64Sfixed64Entry.key");
261 map_sfixed64_sfixed64_val_ = pool->FindFieldByName(
262 "protobuf_unittest.TestMap.MapSfixed64Sfixed64Entry.value");
263 map_int32_float_key_ = pool->FindFieldByName(
264 "protobuf_unittest.TestMap.MapInt32FloatEntry.key");
265 map_int32_float_val_ = pool->FindFieldByName(
266 "protobuf_unittest.TestMap.MapInt32FloatEntry.value");
267 map_int32_double_key_ = pool->FindFieldByName(
268 "protobuf_unittest.TestMap.MapInt32DoubleEntry.key");
269 map_int32_double_val_ = pool->FindFieldByName(
270 "protobuf_unittest.TestMap.MapInt32DoubleEntry.value");
271 map_bool_bool_key_ = pool->FindFieldByName(
272 "protobuf_unittest.TestMap.MapBoolBoolEntry.key");
273 map_bool_bool_val_ = pool->FindFieldByName(
274 "protobuf_unittest.TestMap.MapBoolBoolEntry.value");
275 map_string_string_key_ = pool->FindFieldByName(
276 "protobuf_unittest.TestMap.MapStringStringEntry.key");
277 map_string_string_val_ = pool->FindFieldByName(
278 "protobuf_unittest.TestMap.MapStringStringEntry.value");
279 map_int32_bytes_key_ = pool->FindFieldByName(
280 "protobuf_unittest.TestMap.MapInt32BytesEntry.key");
281 map_int32_bytes_val_ = pool->FindFieldByName(
282 "protobuf_unittest.TestMap.MapInt32BytesEntry.value");
283 map_int32_enum_key_ = pool->FindFieldByName(
284 "protobuf_unittest.TestMap.MapInt32EnumEntry.key");
285 map_int32_enum_val_ = pool->FindFieldByName(
286 "protobuf_unittest.TestMap.MapInt32EnumEntry.value");
287 map_int32_foreign_message_key_ = pool->FindFieldByName(
288 "protobuf_unittest.TestMap.MapInt32ForeignMessageEntry.key");
289 map_int32_foreign_message_val_ = pool->FindFieldByName(
290 "protobuf_unittest.TestMap.MapInt32ForeignMessageEntry.value");
291
292 EXPECT_FALSE(map_enum_foo_ == NULL);
293 EXPECT_FALSE(map_enum_bar_ == NULL);
294 EXPECT_FALSE(map_enum_baz_ == NULL);
295 EXPECT_FALSE(map_int32_int32_key_ == NULL);
296 EXPECT_FALSE(map_int32_int32_val_ == NULL);
297 EXPECT_FALSE(map_int64_int64_key_ == NULL);
298 EXPECT_FALSE(map_int64_int64_val_ == NULL);
299 EXPECT_FALSE(map_uint32_uint32_key_ == NULL);
300 EXPECT_FALSE(map_uint32_uint32_val_ == NULL);
301 EXPECT_FALSE(map_uint64_uint64_key_ == NULL);
302 EXPECT_FALSE(map_uint64_uint64_val_ == NULL);
303 EXPECT_FALSE(map_sint32_sint32_key_ == NULL);
304 EXPECT_FALSE(map_sint32_sint32_val_ == NULL);
305 EXPECT_FALSE(map_sint64_sint64_key_ == NULL);
306 EXPECT_FALSE(map_sint64_sint64_val_ == NULL);
307 EXPECT_FALSE(map_fixed32_fixed32_key_ == NULL);
308 EXPECT_FALSE(map_fixed32_fixed32_val_ == NULL);
309 EXPECT_FALSE(map_fixed64_fixed64_key_ == NULL);
310 EXPECT_FALSE(map_fixed64_fixed64_val_ == NULL);
311 EXPECT_FALSE(map_sfixed32_sfixed32_key_ == NULL);
312 EXPECT_FALSE(map_sfixed32_sfixed32_val_ == NULL);
313 EXPECT_FALSE(map_sfixed64_sfixed64_key_ == NULL);
314 EXPECT_FALSE(map_sfixed64_sfixed64_val_ == NULL);
315 EXPECT_FALSE(map_int32_float_key_ == NULL);
316 EXPECT_FALSE(map_int32_float_val_ == NULL);
317 EXPECT_FALSE(map_int32_double_key_ == NULL);
318 EXPECT_FALSE(map_int32_double_val_ == NULL);
319 EXPECT_FALSE(map_bool_bool_key_ == NULL);
320 EXPECT_FALSE(map_bool_bool_val_ == NULL);
321 EXPECT_FALSE(map_string_string_key_ == NULL);
322 EXPECT_FALSE(map_string_string_val_ == NULL);
323 EXPECT_FALSE(map_int32_bytes_key_ == NULL);
324 EXPECT_FALSE(map_int32_bytes_val_ == NULL);
325 EXPECT_FALSE(map_int32_enum_key_ == NULL);
326 EXPECT_FALSE(map_int32_enum_val_ == NULL);
327 EXPECT_FALSE(map_int32_foreign_message_key_ == NULL);
328 EXPECT_FALSE(map_int32_foreign_message_val_ == NULL);
329}
330
331// Shorthand to get a FieldDescriptor for a field of unittest::TestMap.
332const FieldDescriptor* MapTestUtil::MapReflectionTester::F(const string& name) {
333 const FieldDescriptor* result = NULL;
334 result = base_descriptor_->FindFieldByName(name);
335 GOOGLE_CHECK(result != NULL);
336 return result;
337}
338
339void MapTestUtil::MapReflectionTester::SetMapFieldsViaReflection(
340 Message* message) {
341 const Reflection* reflection = message->GetReflection();
342 Message* sub_message = NULL;
343 Message* sub_foreign_message = NULL;
344
345 // Add first element.
346 sub_message = reflection->AddMessage(message, F("map_int32_int32"));
347 sub_message->GetReflection()
348 ->SetInt32(sub_message, map_int32_int32_key_, 0);
349 sub_message->GetReflection()
350 ->SetInt32(sub_message, map_int32_int32_val_, 0);
351
352 sub_message = reflection->AddMessage(message, F("map_int64_int64"));
353 sub_message->GetReflection()
354 ->SetInt64(sub_message, map_int64_int64_key_, 0);
355 sub_message->GetReflection()
356 ->SetInt64(sub_message, map_int64_int64_val_, 0);
357
358 sub_message = reflection->AddMessage(message, F("map_uint32_uint32"));
359 sub_message->GetReflection()
360 ->SetUInt32(sub_message, map_uint32_uint32_key_, 0);
361 sub_message->GetReflection()
362 ->SetUInt32(sub_message, map_uint32_uint32_val_, 0);
363
364 sub_message = reflection->AddMessage(message, F("map_uint64_uint64"));
365 sub_message->GetReflection()
366 ->SetUInt64(sub_message, map_uint64_uint64_key_, 0);
367 sub_message->GetReflection()
368 ->SetUInt64(sub_message, map_uint64_uint64_val_, 0);
369
370 sub_message = reflection->AddMessage(message, F("map_sint32_sint32"));
371 sub_message->GetReflection()
372 ->SetInt32(sub_message, map_sint32_sint32_key_, 0);
373 sub_message->GetReflection()
374 ->SetInt32(sub_message, map_sint32_sint32_val_, 0);
375
376 sub_message = reflection->AddMessage(message, F("map_sint64_sint64"));
377 sub_message->GetReflection()
378 ->SetInt64(sub_message, map_sint64_sint64_key_, 0);
379 sub_message->GetReflection()
380 ->SetInt64(sub_message, map_sint64_sint64_val_, 0);
381
382 sub_message = reflection->AddMessage(message, F("map_fixed32_fixed32"));
383 sub_message->GetReflection()
384 ->SetUInt32(sub_message, map_fixed32_fixed32_key_, 0);
385 sub_message->GetReflection()
386 ->SetUInt32(sub_message, map_fixed32_fixed32_val_, 0);
387
388 sub_message = reflection->AddMessage(message, F("map_fixed64_fixed64"));
389 sub_message->GetReflection()
390 ->SetUInt64(sub_message, map_fixed64_fixed64_key_, 0);
391 sub_message->GetReflection()
392 ->SetUInt64(sub_message, map_fixed64_fixed64_val_, 0);
393
394 sub_message = reflection->AddMessage(message, F("map_sfixed32_sfixed32"));
395 sub_message->GetReflection()
396 ->SetInt32(sub_message, map_sfixed32_sfixed32_key_, 0);
397 sub_message->GetReflection()
398 ->SetInt32(sub_message, map_sfixed32_sfixed32_val_, 0);
399
400 sub_message = reflection->AddMessage(message, F("map_sfixed64_sfixed64"));
401 sub_message->GetReflection()
402 ->SetInt64(sub_message, map_sfixed64_sfixed64_key_, 0);
403 sub_message->GetReflection()
404 ->SetInt64(sub_message, map_sfixed64_sfixed64_val_, 0);
405
406 sub_message = reflection->AddMessage(message, F("map_int32_float"));
407 sub_message->GetReflection()
408 ->SetInt32(sub_message, map_int32_float_key_, 0);
409 sub_message->GetReflection()
410 ->SetFloat(sub_message, map_int32_float_val_, 0.0);
411
412 sub_message = reflection->AddMessage(message, F("map_int32_double"));
413 sub_message->GetReflection()
414 ->SetInt32(sub_message, map_int32_double_key_, 0);
415 sub_message->GetReflection()
416 ->SetDouble(sub_message, map_int32_double_val_, 0.0);
417
418 sub_message = reflection->AddMessage(message, F("map_bool_bool"));
419 sub_message->GetReflection()
420 ->SetBool(sub_message, map_bool_bool_key_, false);
421 sub_message->GetReflection()
422 ->SetBool(sub_message, map_bool_bool_val_, false);
423
424 sub_message = reflection->AddMessage(message, F("map_string_string"));
425 sub_message->GetReflection()
426 ->SetString(sub_message, map_string_string_key_, "0");
427 sub_message->GetReflection()
428 ->SetString(sub_message, map_string_string_val_, "0");
429
430 sub_message = reflection->AddMessage(message, F("map_int32_bytes"));
431 sub_message->GetReflection()
432 ->SetInt32(sub_message, map_int32_bytes_key_, 0);
433 sub_message->GetReflection()
434 ->SetString(sub_message, map_int32_bytes_val_, "0");
435
436 sub_message = reflection->AddMessage(message, F("map_int32_enum"));
437 sub_message->GetReflection()
438 ->SetInt32(sub_message, map_int32_enum_key_, 0);
439 sub_message->GetReflection()
440 ->SetEnum(sub_message, map_int32_enum_val_, map_enum_bar_);
441
442 sub_message = reflection
443 ->AddMessage(message, F("map_int32_foreign_message"));
444 sub_message->GetReflection()
445 ->SetInt32(sub_message, map_int32_foreign_message_key_, 0);
446 sub_foreign_message = sub_message->GetReflection()->
447 MutableMessage(sub_message, map_int32_foreign_message_val_, NULL);
448 sub_foreign_message->GetReflection()->
449 SetInt32(sub_foreign_message, foreign_c_, 0);
450
451 // Add second element
452 sub_message = reflection->AddMessage(message, F("map_int32_int32"));
453 sub_message->GetReflection()
454 ->SetInt32(sub_message, map_int32_int32_key_, 1);
455 sub_message->GetReflection()
456 ->SetInt32(sub_message, map_int32_int32_val_, 1);
457
458 sub_message = reflection->AddMessage(message, F("map_int64_int64"));
459 sub_message->GetReflection()
460 ->SetInt64(sub_message, map_int64_int64_key_, 1);
461 sub_message->GetReflection()
462 ->SetInt64(sub_message, map_int64_int64_val_, 1);
463
464 sub_message = reflection->AddMessage(message, F("map_uint32_uint32"));
465 sub_message->GetReflection()
466 ->SetUInt32(sub_message, map_uint32_uint32_key_, 1);
467 sub_message->GetReflection()
468 ->SetUInt32(sub_message, map_uint32_uint32_val_, 1);
469
470 sub_message = reflection->AddMessage(message, F("map_uint64_uint64"));
471 sub_message->GetReflection()
472 ->SetUInt64(sub_message, map_uint64_uint64_key_, 1);
473 sub_message->GetReflection()
474 ->SetUInt64(sub_message, map_uint64_uint64_val_, 1);
475
476 sub_message = reflection->AddMessage(message, F("map_sint32_sint32"));
477 sub_message->GetReflection()
478 ->SetInt32(sub_message, map_sint32_sint32_key_, 1);
479 sub_message->GetReflection()
480 ->SetInt32(sub_message, map_sint32_sint32_val_, 1);
481
482 sub_message = reflection->AddMessage(message, F("map_sint64_sint64"));
483 sub_message->GetReflection()
484 ->SetInt64(sub_message, map_sint64_sint64_key_, 1);
485 sub_message->GetReflection()
486 ->SetInt64(sub_message, map_sint64_sint64_val_, 1);
487
488 sub_message = reflection->AddMessage(message, F("map_fixed32_fixed32"));
489 sub_message->GetReflection()
490 ->SetUInt32(sub_message, map_fixed32_fixed32_key_, 1);
491 sub_message->GetReflection()
492 ->SetUInt32(sub_message, map_fixed32_fixed32_val_, 1);
493
494 sub_message = reflection->AddMessage(message, F("map_fixed64_fixed64"));
495 sub_message->GetReflection()
496 ->SetUInt64(sub_message, map_fixed64_fixed64_key_, 1);
497 sub_message->GetReflection()
498 ->SetUInt64(sub_message, map_fixed64_fixed64_val_, 1);
499
500 sub_message = reflection->AddMessage(message, F("map_sfixed32_sfixed32"));
501 sub_message->GetReflection()
502 ->SetInt32(sub_message, map_sfixed32_sfixed32_key_, 1);
503 sub_message->GetReflection()
504 ->SetInt32(sub_message, map_sfixed32_sfixed32_val_, 1);
505
506 sub_message = reflection->AddMessage(message, F("map_sfixed64_sfixed64"));
507 sub_message->GetReflection()
508 ->SetInt64(sub_message, map_sfixed64_sfixed64_key_, 1);
509 sub_message->GetReflection()
510 ->SetInt64(sub_message, map_sfixed64_sfixed64_val_, 1);
511
512 sub_message = reflection->AddMessage(message, F("map_int32_float"));
513 sub_message->GetReflection()
514 ->SetInt32(sub_message, map_int32_float_key_, 1);
515 sub_message->GetReflection()
516 ->SetFloat(sub_message, map_int32_float_val_, 1.0);
517
518 sub_message = reflection->AddMessage(message, F("map_int32_double"));
519 sub_message->GetReflection()
520 ->SetInt32(sub_message, map_int32_double_key_, 1);
521 sub_message->GetReflection()
522 ->SetDouble(sub_message, map_int32_double_val_, 1.0);
523
524 sub_message = reflection->AddMessage(message, F("map_bool_bool"));
525 sub_message->GetReflection()
526 ->SetBool(sub_message, map_bool_bool_key_, true);
527 sub_message->GetReflection()
528 ->SetBool(sub_message, map_bool_bool_val_, true);
529
530 sub_message = reflection->AddMessage(message, F("map_string_string"));
531 sub_message->GetReflection()
532 ->SetString(sub_message, map_string_string_key_, "1");
533 sub_message->GetReflection()
534 ->SetString(sub_message, map_string_string_val_, "1");
535
536 sub_message = reflection->AddMessage(message, F("map_int32_bytes"));
537 sub_message->GetReflection()
538 ->SetInt32(sub_message, map_int32_bytes_key_, 1);
539 sub_message->GetReflection()
540 ->SetString(sub_message, map_int32_bytes_val_, "1");
541
542 sub_message = reflection->AddMessage(message, F("map_int32_enum"));
543 sub_message->GetReflection()
544 ->SetInt32(sub_message, map_int32_enum_key_, 1);
545 sub_message->GetReflection()
546 ->SetEnum(sub_message, map_int32_enum_val_, map_enum_baz_);
547
548 sub_message = reflection
549 ->AddMessage(message, F("map_int32_foreign_message"));
550 sub_message->GetReflection()
551 ->SetInt32(sub_message, map_int32_foreign_message_key_, 1);
552 sub_foreign_message = sub_message->GetReflection()->
553 MutableMessage(sub_message, map_int32_foreign_message_val_, NULL);
554 sub_foreign_message->GetReflection()->
555 SetInt32(sub_foreign_message, foreign_c_, 1);
556}
557
558void MapTestUtil::MapReflectionTester::ClearMapFieldsViaReflection(
559 Message* message) {
560 const Reflection* reflection = message->GetReflection();
561
562 reflection->ClearField(message, F("map_int32_int32"));
563 reflection->ClearField(message, F("map_int64_int64"));
564 reflection->ClearField(message, F("map_uint32_uint32"));
565 reflection->ClearField(message, F("map_uint64_uint64"));
566 reflection->ClearField(message, F("map_sint32_sint32"));
567 reflection->ClearField(message, F("map_sint64_sint64"));
568 reflection->ClearField(message, F("map_fixed32_fixed32"));
569 reflection->ClearField(message, F("map_fixed64_fixed64"));
570 reflection->ClearField(message, F("map_sfixed32_sfixed32"));
571 reflection->ClearField(message, F("map_sfixed64_sfixed64"));
572 reflection->ClearField(message, F("map_int32_float"));
573 reflection->ClearField(message, F("map_int32_double"));
574 reflection->ClearField(message, F("map_bool_bool"));
575 reflection->ClearField(message, F("map_string_string"));
576 reflection->ClearField(message, F("map_int32_bytes"));
577 reflection->ClearField(message, F("map_int32_enum"));
578 reflection->ClearField(message, F("map_int32_foreign_message"));
579}
580
581void MapTestUtil::MapReflectionTester::ModifyMapFieldsViaReflection(
582 Message* message) {
583 const Reflection* reflection = message->GetReflection();
584 Message* sub_message;
585 Message* sub_foreign_message;
586
587 // Find out which one's key is 0.
588 int size = reflection->FieldSize(*message, F("map_int32_int32"));
589 int target = 0;
590 for (int i = 0; i < size; i++) {
591 const Message& temp_message = reflection
592 ->GetRepeatedMessage(*message, F("map_int32_int32"), i);
593 if (temp_message.GetReflection()
594 ->GetInt32(temp_message, map_int32_int32_key_) == 1) {
595 target = i;
596 }
597 }
598
599 sub_message = reflection
600 ->MutableRepeatedMessage(message, F("map_int32_int32"), target);
601 sub_message->GetReflection()
602 ->SetInt32(sub_message, map_int32_int32_val_, 2);
603 sub_message = reflection
604 ->MutableRepeatedMessage(message, F("map_int64_int64"), target);
605 sub_message->GetReflection()
606 ->SetInt64(sub_message, map_int64_int64_val_, 2);
607 sub_message = reflection
608 ->MutableRepeatedMessage(message, F("map_uint32_uint32"), target);
609 sub_message->GetReflection()
610 ->SetUInt32(sub_message, map_uint32_uint32_val_, 2);
611 sub_message = reflection
612 ->MutableRepeatedMessage(message, F("map_uint64_uint64"), target);
613 sub_message->GetReflection()
614 ->SetUInt64(sub_message, map_uint64_uint64_val_, 2);
615 sub_message = reflection
616 ->MutableRepeatedMessage(message, F("map_sint32_sint32"), target);
617 sub_message->GetReflection()
618 ->SetInt32(sub_message, map_sint32_sint32_val_, 2);
619 sub_message = reflection
620 ->MutableRepeatedMessage(message, F("map_sint64_sint64"), target);
621 sub_message->GetReflection()
622 ->SetInt64(sub_message, map_sint64_sint64_val_, 2);
623 sub_message = reflection
624 ->MutableRepeatedMessage(message, F("map_fixed32_fixed32"), target);
625 sub_message->GetReflection()
626 ->SetUInt32(sub_message, map_fixed32_fixed32_val_, 2);
627 sub_message = reflection
628 ->MutableRepeatedMessage(message, F("map_fixed64_fixed64"), target);
629 sub_message->GetReflection()
630 ->SetUInt64(sub_message, map_fixed64_fixed64_val_, 2);
631 sub_message = reflection
632 ->MutableRepeatedMessage(message, F("map_sfixed32_sfixed32"), target);
633 sub_message->GetReflection()
634 ->SetInt32(sub_message, map_sfixed32_sfixed32_val_, 2);
635 sub_message = reflection
636 ->MutableRepeatedMessage(message, F("map_sfixed64_sfixed64"), target);
637 sub_message->GetReflection()
638 ->SetInt64(sub_message, map_sfixed64_sfixed64_val_, 2);
639 sub_message = reflection
640 ->MutableRepeatedMessage(message, F("map_int32_float"), target);
641 sub_message->GetReflection()
642 ->SetFloat(sub_message, map_int32_float_val_, 2.0);
643 sub_message = reflection
644 ->MutableRepeatedMessage(message, F("map_int32_double"), target);
645 sub_message->GetReflection()
646 ->SetDouble(sub_message, map_int32_double_val_, 2.0);
647 sub_message = reflection
648 ->MutableRepeatedMessage(message, F("map_bool_bool"), target);
649 sub_message->GetReflection()
650 ->SetBool(sub_message, map_bool_bool_val_, false);
651 sub_message = reflection
652 ->MutableRepeatedMessage(message, F("map_string_string"), target);
653 sub_message->GetReflection()
654 ->SetString(sub_message, map_string_string_val_, "2");
655 sub_message = reflection
656 ->MutableRepeatedMessage(message, F("map_int32_bytes"), target);
657 sub_message->GetReflection()
658 ->SetString(sub_message, map_int32_bytes_val_, "2");
659 sub_message = reflection
660 ->MutableRepeatedMessage(message, F("map_int32_enum"), target);
661 sub_message->GetReflection()
662 ->SetEnum(sub_message, map_int32_enum_val_, map_enum_foo_);
663 sub_message = reflection
664 ->MutableRepeatedMessage(message, F("map_int32_foreign_message"), target);
665 sub_foreign_message = sub_message->GetReflection()->
666 MutableMessage(sub_message, map_int32_foreign_message_val_, NULL);
667 sub_foreign_message->GetReflection()->
668 SetInt32(sub_foreign_message, foreign_c_, 2);
669}
670
671void MapTestUtil::MapReflectionTester::RemoveLastMapsViaReflection(
672 Message* message) {
673 const Reflection* reflection = message->GetReflection();
674
675 vector<const FieldDescriptor*> output;
676 reflection->ListFields(*message, &output);
677 for (int i = 0; i < output.size(); ++i) {
678 const FieldDescriptor* field = output[i];
679 if (!field->is_repeated()) continue;
680 reflection->RemoveLast(message, field);
681 }
682}
683
684void MapTestUtil::MapReflectionTester::ReleaseLastMapsViaReflection(
685 Message* message) {
686 const Reflection* reflection = message->GetReflection();
687
688 vector<const FieldDescriptor*> output;
689 reflection->ListFields(*message, &output);
690 for (int i = 0; i < output.size(); ++i) {
691 const FieldDescriptor* field = output[i];
692 if (!field->is_repeated()) continue;
693 if (field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) continue;
694
695 Message* released = reflection->ReleaseLast(message, field);
696 ASSERT_TRUE(released != NULL) << "ReleaseLast returned NULL for: "
697 << field->name();
698 delete released;
699 }
700}
701
702void MapTestUtil::MapReflectionTester::SwapMapsViaReflection(Message* message) {
703 const Reflection* reflection = message->GetReflection();
704 vector<const FieldDescriptor*> output;
705 reflection->ListFields(*message, &output);
706 for (int i = 0; i < output.size(); ++i) {
707 const FieldDescriptor* field = output[i];
708 if (!field->is_repeated()) continue;
709 reflection->SwapElements(message, field, 0, 1);
710 }
711}
712
713void MapTestUtil::MapReflectionTester::
714 MutableUnknownFieldsOfMapFieldsViaReflection(Message* message) {
715 const Reflection* reflection = message->GetReflection();
716 Message* sub_message = NULL;
717
718 sub_message = reflection->AddMessage(message, F("map_int32_int32"));
719 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
720 NULL);
721 sub_message = reflection->AddMessage(message, F("map_int64_int64"));
722 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
723 NULL);
724 sub_message = reflection->AddMessage(message, F("map_uint32_uint32"));
725 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
726 NULL);
727 sub_message = reflection->AddMessage(message, F("map_uint64_uint64"));
728 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
729 NULL);
730 sub_message = reflection->AddMessage(message, F("map_sint32_sint32"));
731 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
732 NULL);
733 sub_message = reflection->AddMessage(message, F("map_sint64_sint64"));
734 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
735 NULL);
736 sub_message = reflection->AddMessage(message, F("map_fixed32_fixed32"));
737 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
738 NULL);
739 sub_message = reflection->AddMessage(message, F("map_fixed64_fixed64"));
740 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
741 NULL);
742 sub_message = reflection->AddMessage(message, F("map_sfixed32_sfixed32"));
743 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
744 NULL);
745 sub_message = reflection->AddMessage(message, F("map_sfixed64_sfixed64"));
746 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
747 NULL);
748 sub_message = reflection->AddMessage(message, F("map_int32_float"));
749 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
750 NULL);
751 sub_message = reflection->AddMessage(message, F("map_int32_double"));
752 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
753 NULL);
754 sub_message = reflection->AddMessage(message, F("map_bool_bool"));
755 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
756 NULL);
757 sub_message = reflection->AddMessage(message, F("map_string_string"));
758 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
759 NULL);
760 sub_message = reflection->AddMessage(message, F("map_int32_bytes"));
761 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
762 NULL);
763 sub_message = reflection->AddMessage(message, F("map_int32_enum"));
764 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
765 NULL);
766 sub_message = reflection->AddMessage(message, F("map_int32_foreign_message"));
767 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=
768 NULL);
769}
770
771void MapTestUtil::MapReflectionTester::ExpectMapFieldsSetViaReflection(
772 const Message& message) {
773 string scratch;
774 const Reflection* reflection = message.GetReflection();
775 const Message* sub_message;
776
777 // -----------------------------------------------------------------
778
779 ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_int32")));
780 ASSERT_EQ(2, reflection->FieldSize(message, F("map_int64_int64")));
781 ASSERT_EQ(2, reflection->FieldSize(message, F("map_uint32_uint32")));
782 ASSERT_EQ(2, reflection->FieldSize(message, F("map_uint64_uint64")));
783 ASSERT_EQ(2, reflection->FieldSize(message, F("map_sint32_sint32")));
784 ASSERT_EQ(2, reflection->FieldSize(message, F("map_sint64_sint64")));
785 ASSERT_EQ(2, reflection->FieldSize(message, F("map_fixed32_fixed32")));
786 ASSERT_EQ(2, reflection->FieldSize(message, F("map_fixed64_fixed64")));
787 ASSERT_EQ(2, reflection->FieldSize(message, F("map_sfixed32_sfixed32")));
788 ASSERT_EQ(2, reflection->FieldSize(message, F("map_sfixed64_sfixed64")));
789 ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_float")));
790 ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_double")));
791 ASSERT_EQ(2, reflection->FieldSize(message, F("map_bool_bool")));
792 ASSERT_EQ(2, reflection->FieldSize(message, F("map_string_string")));
793 ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_bytes")));
794 ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_enum")));
795 ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_foreign_message")));
796
797 {
798 std::map<int32, int32> map;
799 map[0] = 0;
800 map[1] = 1;
801 for (int i = 0; i < 2; i++) {
802 sub_message =
803 &reflection->GetRepeatedMessage(message, F("map_int32_int32"), i);
804 int32 key = sub_message->GetReflection()->GetInt32(
805 *sub_message, map_int32_int32_key_);
806 int32 val = sub_message->GetReflection()->GetInt32(
807 *sub_message, map_int32_int32_val_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]808 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]809 }
810 }
811 {
812 std::map<int64, int64> map;
813 map[0] = 0;
814 map[1] = 1;
815 for (int i = 0; i < 2; i++) {
816 sub_message =
817 &reflection->GetRepeatedMessage(message, F("map_int64_int64"), i);
818 int64 key = sub_message->GetReflection()->GetInt64(
819 *sub_message, map_int64_int64_key_);
820 int64 val = sub_message->GetReflection()->GetInt64(
821 *sub_message, map_int64_int64_val_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]822 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]823 }
824 }
825 {
826 std::map<uint32, uint32> map;
827 map[0] = 0;
828 map[1] = 1;
829 for (int i = 0; i < 2; i++) {
830 sub_message =
831 &reflection->GetRepeatedMessage(message, F("map_uint32_uint32"), i);
832 uint32 key = sub_message->GetReflection()->GetUInt32(
833 *sub_message, map_uint32_uint32_key_);
834 uint32 val = sub_message->GetReflection()->GetUInt32(
835 *sub_message, map_uint32_uint32_val_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]836 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]837 }
838 }
839 {
840 std::map<uint64, uint64> map;
841 map[0] = 0;
842 map[1] = 1;
843 for (int i = 0; i < 2; i++) {
844 sub_message =
845 &reflection->GetRepeatedMessage(message, F("map_uint64_uint64"), i);
846 uint64 key = sub_message->GetReflection()->GetUInt64(
847 *sub_message, map_uint64_uint64_key_);
848 uint64 val = sub_message->GetReflection()->GetUInt64(
849 *sub_message, map_uint64_uint64_val_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]850 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]851 }
852 }
853 {
854 std::map<int32, int32> map;
855 map[0] = 0;
856 map[1] = 1;
857 for (int i = 0; i < 2; i++) {
858 sub_message =
859 &reflection->GetRepeatedMessage(message, F("map_sint32_sint32"), i);
860 int32 key = sub_message->GetReflection()->GetInt32(
861 *sub_message, map_sint32_sint32_key_);
862 int32 val = sub_message->GetReflection()->GetInt32(
863 *sub_message, map_sint32_sint32_val_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]864 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]865 }
866 }
867 {
868 std::map<int64, int64> map;
869 map[0] = 0;
870 map[1] = 1;
871 for (int i = 0; i < 2; i++) {
872 sub_message =
873 &reflection->GetRepeatedMessage(message, F("map_sint64_sint64"), i);
874 int64 key = sub_message->GetReflection()->GetInt64(
875 *sub_message, map_sint64_sint64_key_);
876 int64 val = sub_message->GetReflection()->GetInt64(
877 *sub_message, map_sint64_sint64_val_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]878 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]879 }
880 }
881 {
882 std::map<uint32, uint32> map;
883 map[0] = 0;
884 map[1] = 1;
885 for (int i = 0; i < 2; i++) {
886 sub_message =
887 &reflection->GetRepeatedMessage(message, F("map_fixed32_fixed32"), i);
888 uint32 key = sub_message->GetReflection()->GetUInt32(
889 *sub_message, map_fixed32_fixed32_key_);
890 uint32 val = sub_message->GetReflection()->GetUInt32(
891 *sub_message, map_fixed32_fixed32_val_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]892 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]893 }
894 }
895 {
896 std::map<uint64, uint64> map;
897 map[0] = 0;
898 map[1] = 1;
899 for (int i = 0; i < 2; i++) {
900 sub_message =
901 &reflection->GetRepeatedMessage(message, F("map_fixed64_fixed64"), i);
902 uint64 key = sub_message->GetReflection()->GetUInt64(
903 *sub_message, map_fixed64_fixed64_key_);
904 uint64 val = sub_message->GetReflection()->GetUInt64(
905 *sub_message, map_fixed64_fixed64_val_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]906 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]907 }
908 }
909 {
910 std::map<int32, int32> map;
911 map[0] = 0;
912 map[1] = 1;
913 for (int i = 0; i < 2; i++) {
914 sub_message = &reflection->GetRepeatedMessage(
915 message, F("map_sfixed32_sfixed32"), i);
916 int32 key = sub_message->GetReflection()->GetInt32(
917 *sub_message, map_sfixed32_sfixed32_key_);
918 int32 val = sub_message->GetReflection()->GetInt32(
919 *sub_message, map_sfixed32_sfixed32_val_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]920 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]921 }
922 }
923 {
924 std::map<int64, int64> map;
925 map[0] = 0;
926 map[1] = 1;
927 for (int i = 0; i < 2; i++) {
928 sub_message = &reflection->GetRepeatedMessage(
929 message, F("map_sfixed64_sfixed64"), i);
930 int64 key = sub_message->GetReflection()->GetInt64(
931 *sub_message, map_sfixed64_sfixed64_key_);
932 int64 val = sub_message->GetReflection()->GetInt64(
933 *sub_message, map_sfixed64_sfixed64_val_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]934 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]935 }
936 }
937 {
938 std::map<int32, float> map;
939 map[0] = 0.0;
940 map[1] = 1.0;
941 for (int i = 0; i < 2; i++) {
942 sub_message =
943 &reflection->GetRepeatedMessage(message, F("map_int32_float"), i);
944 int32 key = sub_message->GetReflection()->GetInt32(
945 *sub_message, map_int32_float_key_);
946 float val = sub_message->GetReflection()->GetFloat(
947 *sub_message, map_int32_float_val_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]948 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]949 }
950 }
951 {
952 std::map<int32, double> map;
953 map[0] = 0.0;
954 map[1] = 1.0;
955 for (int i = 0; i < 2; i++) {
956 sub_message =
957 &reflection->GetRepeatedMessage(message, F("map_int32_double"), i);
958 int32 key = sub_message->GetReflection()->GetInt32(
959 *sub_message, map_int32_double_key_);
960 double val = sub_message->GetReflection()->GetDouble(
961 *sub_message, map_int32_double_val_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]962 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]963 }
964 }
965 {
966 std::map<bool, bool> map;
967 map[false] = false;
968 map[true] = true;
969 for (int i = 0; i < 2; i++) {
970 sub_message =
971 &reflection->GetRepeatedMessage(message, F("map_bool_bool"), i);
972 bool key = sub_message->GetReflection()->GetBool(
973 *sub_message, map_bool_bool_key_);
974 bool val = sub_message->GetReflection()->GetBool(
975 *sub_message, map_bool_bool_val_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]976 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]977 }
978 }
979 {
980 std::map<string, string> map;
981 map["0"] = "0";
982 map["1"] = "1";
983 for (int i = 0; i < 2; i++) {
984 sub_message =
985 &reflection->GetRepeatedMessage(message, F("map_string_string"), i);
986 string key = sub_message->GetReflection()->GetString(
987 *sub_message, map_string_string_key_);
988 string val = sub_message->GetReflection()->GetString(
989 *sub_message, map_string_string_val_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]990 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]991 }
992 }
993 {
994 std::map<int32, string> map;
995 map[0] = "0";
996 map[1] = "1";
997 for (int i = 0; i < 2; i++) {
998 sub_message =
999 &reflection->GetRepeatedMessage(message, F("map_int32_bytes"), i);
1000 int32 key = sub_message->GetReflection()->GetInt32(
1001 *sub_message, map_int32_bytes_key_);
1002 string val = sub_message->GetReflection()->GetString(
1003 *sub_message, map_int32_bytes_val_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]1004 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]1005 }
1006 }
1007 {
1008 std::map<int32, const EnumValueDescriptor*> map;
1009 map[0] = map_enum_bar_;
1010 map[1] = map_enum_baz_;
1011 for (int i = 0; i < 2; i++) {
1012 sub_message = &reflection->GetRepeatedMessage(
1013 message, F("map_int32_enum"), i);
1014 int32 key = sub_message->GetReflection()->GetInt32(
1015 *sub_message, map_int32_enum_key_);
1016 const EnumValueDescriptor* val = sub_message->GetReflection()->GetEnum(
1017 *sub_message, map_int32_enum_val_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]1018 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]1019 }
1020 }
1021 {
1022 std::map<int32, int32> map;
1023 map[0] = 0;
1024 map[1] = 1;
1025 for (int i = 0; i < 2; i++) {
1026 sub_message = &reflection->GetRepeatedMessage(
1027 message, F("map_int32_foreign_message"), i);
1028 int32 key = sub_message->GetReflection()->GetInt32(
1029 *sub_message, map_int32_foreign_message_key_);
1030 const Message& foreign_message = sub_message->GetReflection()->GetMessage(
1031 *sub_message, map_int32_foreign_message_val_);
1032 int32 val = foreign_message.GetReflection()->GetInt32(
1033 foreign_message, foreign_c_);
Feng Xiaobe20ae02014-12-05 02:54:43 -0800[diff] [blame]1034 EXPECT_EQ(map[key], val);
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]1035 }
1036 }
1037}
1038
1039void MapTestUtil::MapReflectionTester::ExpectClearViaReflection(
1040 const Message& message) {
1041 const Reflection* reflection = message.GetReflection();
1042 // Map fields are empty.
1043 EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_int32")));
1044 EXPECT_EQ(0, reflection->FieldSize(message, F("map_int64_int64")));
1045 EXPECT_EQ(0, reflection->FieldSize(message, F("map_uint32_uint32")));
1046 EXPECT_EQ(0, reflection->FieldSize(message, F("map_uint64_uint64")));
1047 EXPECT_EQ(0, reflection->FieldSize(message, F("map_sint32_sint32")));
1048 EXPECT_EQ(0, reflection->FieldSize(message, F("map_sint64_sint64")));
1049 EXPECT_EQ(0, reflection->FieldSize(message, F("map_fixed32_fixed32")));
1050 EXPECT_EQ(0, reflection->FieldSize(message, F("map_fixed64_fixed64")));
1051 EXPECT_EQ(0, reflection->FieldSize(message, F("map_sfixed32_sfixed32")));
1052 EXPECT_EQ(0, reflection->FieldSize(message, F("map_sfixed64_sfixed64")));
1053 EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_float")));
1054 EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_double")));
1055 EXPECT_EQ(0, reflection->FieldSize(message, F("map_bool_bool")));
1056 EXPECT_EQ(0, reflection->FieldSize(message, F("map_string_string")));
1057 EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_bytes")));
1058 EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_enum")));
1059 EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_foreign_message")));
1060}
1061
1062void MapTestUtil::MapReflectionTester::ExpectMapEntryClearViaReflection(
1063 Message* message) {
1064 const Reflection* reflection = message->GetReflection();
1065 const Message* sub_message;
1066
1067 {
1068 const FieldDescriptor* descriptor = F("map_int32_int32");
1069 const FieldDescriptor* key_descriptor =
1070 descriptor->message_type()->FindFieldByName("key");
1071 const FieldDescriptor* value_descriptor =
1072 descriptor->message_type()->FindFieldByName("value");
1073 sub_message = reflection->AddMessage(message, F("map_int32_int32"));
1074 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message,
1075 key_descriptor));
1076 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message,
1077 value_descriptor));
1078 }
1079 {
1080 const FieldDescriptor* descriptor = F("map_int64_int64");
1081 const FieldDescriptor* key_descriptor =
1082 descriptor->message_type()->FindFieldByName("key");
1083 const FieldDescriptor* value_descriptor =
1084 descriptor->message_type()->FindFieldByName("value");
1085 sub_message = reflection->AddMessage(message, F("map_int64_int64"));
1086 EXPECT_EQ(0, sub_message->GetReflection()->GetInt64(*sub_message,
1087 key_descriptor));
1088 EXPECT_EQ(0, sub_message->GetReflection()->GetInt64(*sub_message,
1089 value_descriptor));
1090 }
1091 {
1092 const FieldDescriptor* descriptor = F("map_uint32_uint32");
1093 const FieldDescriptor* key_descriptor =
1094 descriptor->message_type()->FindFieldByName("key");
1095 const FieldDescriptor* value_descriptor =
1096 descriptor->message_type()->FindFieldByName("value");
1097 sub_message = reflection->AddMessage(message, F("map_uint32_uint32"));
1098 EXPECT_EQ(0, sub_message->GetReflection()->GetUInt32(*sub_message,
1099 key_descriptor));
1100 EXPECT_EQ(0, sub_message->GetReflection()->GetUInt32(*sub_message,
1101 value_descriptor));
1102 }
1103 {
1104 const FieldDescriptor* descriptor = F("map_uint64_uint64");
1105 const FieldDescriptor* key_descriptor =
1106 descriptor->message_type()->FindFieldByName("key");
1107 const FieldDescriptor* value_descriptor =
1108 descriptor->message_type()->FindFieldByName("value");
1109 sub_message = reflection->AddMessage(message, F("map_uint64_uint64"));
1110 EXPECT_EQ(0, sub_message->GetReflection()->GetUInt64(*sub_message,
1111 key_descriptor));
1112 EXPECT_EQ(0, sub_message->GetReflection()->GetUInt64(*sub_message,
1113 value_descriptor));
1114 }
1115 {
1116 const FieldDescriptor* descriptor = F("map_sint32_sint32");
1117 const FieldDescriptor* key_descriptor =
1118 descriptor->message_type()->FindFieldByName("key");
1119 const FieldDescriptor* value_descriptor =
1120 descriptor->message_type()->FindFieldByName("value");
1121 sub_message = reflection->AddMessage(message, F("map_sint32_sint32"));
1122 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message,
1123 key_descriptor));
1124 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message,
1125 value_descriptor));
1126 }
1127 {
1128 const FieldDescriptor* descriptor = F("map_sint64_sint64");
1129 const FieldDescriptor* key_descriptor =
1130 descriptor->message_type()->FindFieldByName("key");
1131 const FieldDescriptor* value_descriptor =
1132 descriptor->message_type()->FindFieldByName("value");
1133 sub_message = reflection->AddMessage(message, F("map_sint64_sint64"));
1134 EXPECT_EQ(0, sub_message->GetReflection()->GetInt64(*sub_message,
1135 key_descriptor));
1136 EXPECT_EQ(0, sub_message->GetReflection()->GetInt64(*sub_message,
1137 value_descriptor));
1138 }
1139 {
1140 const FieldDescriptor* descriptor = F("map_fixed32_fixed32");
1141 const FieldDescriptor* key_descriptor =
1142 descriptor->message_type()->FindFieldByName("key");
1143 const FieldDescriptor* value_descriptor =
1144 descriptor->message_type()->FindFieldByName("value");
1145 sub_message = reflection->AddMessage(message, F("map_fixed32_fixed32"));
1146 EXPECT_EQ(0, sub_message->GetReflection()->GetUInt32(*sub_message,
1147 key_descriptor));
1148 EXPECT_EQ(0, sub_message->GetReflection()->GetUInt32(*sub_message,
1149 value_descriptor));
1150 }
1151 {
1152 const FieldDescriptor* descriptor = F("map_fixed64_fixed64");
1153 const FieldDescriptor* key_descriptor =
1154 descriptor->message_type()->FindFieldByName("key");
1155 const FieldDescriptor* value_descriptor =
1156 descriptor->message_type()->FindFieldByName("value");
1157 sub_message = reflection->AddMessage(message, F("map_fixed64_fixed64"));
1158 EXPECT_EQ(0, sub_message->GetReflection()->GetUInt64(*sub_message,
1159 key_descriptor));
1160 EXPECT_EQ(0, sub_message->GetReflection()->GetUInt64(*sub_message,
1161 value_descriptor));
1162 }
1163 {
1164 const FieldDescriptor* descriptor = F("map_sfixed32_sfixed32");
1165 const FieldDescriptor* key_descriptor =
1166 descriptor->message_type()->FindFieldByName("key");
1167 const FieldDescriptor* value_descriptor =
1168 descriptor->message_type()->FindFieldByName("value");
1169 sub_message = reflection->AddMessage(message, F("map_sfixed32_sfixed32"));
1170 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message,
1171 key_descriptor));
1172 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message,
1173 value_descriptor));
1174 }
1175 {
1176 const FieldDescriptor* descriptor = F("map_sfixed64_sfixed64");
1177 const FieldDescriptor* key_descriptor =
1178 descriptor->message_type()->FindFieldByName("key");
1179 const FieldDescriptor* value_descriptor =
1180 descriptor->message_type()->FindFieldByName("value");
1181 sub_message = reflection->AddMessage(message, F("map_sfixed64_sfixed64"));
1182 EXPECT_EQ(0, sub_message->GetReflection()->GetInt64(*sub_message,
1183 key_descriptor));
1184 EXPECT_EQ(0, sub_message->GetReflection()->GetInt64(*sub_message,
1185 value_descriptor));
1186 }
1187 {
1188 const FieldDescriptor* descriptor = F("map_int32_float");
1189 const FieldDescriptor* key_descriptor =
1190 descriptor->message_type()->FindFieldByName("key");
1191 const FieldDescriptor* value_descriptor =
1192 descriptor->message_type()->FindFieldByName("value");
1193 sub_message = reflection->AddMessage(message, F("map_int32_float"));
1194 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message,
1195 key_descriptor));
1196 EXPECT_EQ(0, sub_message->GetReflection()->GetFloat(*sub_message,
1197 value_descriptor));
1198 }
1199 {
1200 const FieldDescriptor* descriptor = F("map_int32_double");
1201 const FieldDescriptor* key_descriptor =
1202 descriptor->message_type()->FindFieldByName("key");
1203 const FieldDescriptor* value_descriptor =
1204 descriptor->message_type()->FindFieldByName("value");
1205 sub_message = reflection->AddMessage(message, F("map_int32_double"));
1206 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message,
1207 key_descriptor));
1208 EXPECT_EQ(0, sub_message->GetReflection()->GetDouble(*sub_message,
1209 value_descriptor));
1210 }
1211 {
1212 const FieldDescriptor* descriptor = F("map_bool_bool");
1213 const FieldDescriptor* key_descriptor =
1214 descriptor->message_type()->FindFieldByName("key");
1215 const FieldDescriptor* value_descriptor =
1216 descriptor->message_type()->FindFieldByName("value");
1217 sub_message = reflection->AddMessage(message, F("map_bool_bool"));
1218 EXPECT_EQ(false, sub_message->GetReflection()->GetBool(*sub_message,
1219 key_descriptor));
1220 EXPECT_EQ(false, sub_message->GetReflection()->GetBool(*sub_message,
1221 value_descriptor));
1222 }
1223 {
1224 const FieldDescriptor* descriptor = F("map_string_string");
1225 const FieldDescriptor* key_descriptor =
1226 descriptor->message_type()->FindFieldByName("key");
1227 const FieldDescriptor* value_descriptor =
1228 descriptor->message_type()->FindFieldByName("value");
1229 sub_message = reflection->AddMessage(message, F("map_string_string"));
1230 EXPECT_EQ("", sub_message->GetReflection()->GetString(*sub_message,
1231 key_descriptor));
1232 EXPECT_EQ("", sub_message->GetReflection()->GetString(*sub_message,
1233 value_descriptor));
1234 }
1235 {
1236 const FieldDescriptor* descriptor = F("map_int32_bytes");
1237 const FieldDescriptor* key_descriptor =
1238 descriptor->message_type()->FindFieldByName("key");
1239 const FieldDescriptor* value_descriptor =
1240 descriptor->message_type()->FindFieldByName("value");
1241 sub_message = reflection->AddMessage(message, F("map_int32_bytes"));
1242 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message,
1243 key_descriptor));
1244 EXPECT_EQ("", sub_message->GetReflection()->GetString(*sub_message,
1245 value_descriptor));
1246 }
1247 {
1248 const FieldDescriptor* descriptor = F("map_int32_enum");
1249 const FieldDescriptor* key_descriptor =
1250 descriptor->message_type()->FindFieldByName("key");
1251 const FieldDescriptor* value_descriptor =
1252 descriptor->message_type()->FindFieldByName("value");
1253 sub_message = reflection->AddMessage(message, F("map_int32_enum"));
1254 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message,
1255 key_descriptor));
Jisi Liu885b6122015-02-28 14:51:22 -0800[diff] [blame^]1256 EXPECT_EQ(0, sub_message->GetReflection()
1257 ->GetEnum(*sub_message, value_descriptor)
1258 ->number());
Feng Xiaof157a562014-11-14 11:50:31 -0800[diff] [blame]1259 }
1260 // Map using message as value has been tested in other place. Thus, we don't
1261 // test it here.
1262}
1263
1264} // namespace protobuf
1265} // namespace google