1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2023 Google LLC. All rights reserved.
3 //
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file or at
6 // https://developers.google.com/open-source/licenses/bsd
7
8 #include <cstddef>
9 #include <cstdint>
10 #include <string>
11 #include <string_view>
12 #include <vector>
13
14 #include <gmock/gmock.h>
15 #include <gtest/gtest.h>
16 #include "google/protobuf/test_messages_proto3.upb.h"
17 #include "upb/base/status.hpp"
18 #include "upb/base/string_view.h"
19 #include "upb/base/upcast.h"
20 #include "upb/json/decode.h"
21 #include "upb/json/encode.h"
22 #include "upb/mem/arena.h"
23 #include "upb/mem/arena.hpp"
24 #include "upb/message/array.h"
25 #include "upb/message/map.h"
26 #include "upb/message/message.h"
27 #include "upb/message/test.upb.h"
28 #include "upb/message/test.upb_minitable.h"
29 #include "upb/message/test.upbdefs.h"
30 #include "upb/message/value.h"
31 #include "upb/mini_table/extension_registry.h"
32 #include "upb/mini_table/field.h"
33 #include "upb/mini_table/message.h"
34 #include "upb/reflection/def.h"
35 #include "upb/reflection/def.hpp"
36 #include "upb/reflection/message.h"
37 #include "upb/test/fuzz_util.h"
38 #include "upb/wire/decode.h"
39 #include "upb/wire/encode.h"
40
VerifyMessage(const upb_test_TestExtensions * ext_msg)41 void VerifyMessage(const upb_test_TestExtensions* ext_msg) {
42 EXPECT_TRUE(upb_test_TestExtensions_has_optional_int32_ext(ext_msg));
43 // EXPECT_FALSE(upb_test_TestExtensions_Nested_has_optional_int32_ext(ext_msg));
44 EXPECT_TRUE(upb_test_has_optional_msg_ext(ext_msg));
45
46 EXPECT_EQ(123, upb_test_TestExtensions_optional_int32_ext(ext_msg));
47 const protobuf_test_messages_proto3_TestAllTypesProto3* ext_submsg =
48 upb_test_optional_msg_ext(ext_msg);
49 EXPECT_TRUE(ext_submsg != nullptr);
50 EXPECT_EQ(456,
51 protobuf_test_messages_proto3_TestAllTypesProto3_optional_int32(
52 ext_submsg));
53 }
54
TEST(MessageTest,Extensions)55 TEST(MessageTest, Extensions) {
56 upb::Arena arena;
57 upb_test_TestExtensions* ext_msg = upb_test_TestExtensions_new(arena.ptr());
58
59 EXPECT_FALSE(upb_test_TestExtensions_has_optional_int32_ext(ext_msg));
60 // EXPECT_FALSE(upb_test_TestExtensions_Nested_has_optional_int32_ext(ext_msg));
61 EXPECT_FALSE(upb_test_has_optional_msg_ext(ext_msg));
62
63 upb::DefPool defpool;
64 upb::MessageDefPtr m(upb_test_TestExtensions_getmsgdef(defpool.ptr()));
65 EXPECT_TRUE(m.ptr() != nullptr);
66
67 std::string json = R"json(
68 {
69 "[upb_test.TestExtensions.optional_int32_ext]": 123,
70 "[upb_test.TestExtensions.Nested.repeated_int32_ext]": [2, 4, 6],
71 "[upb_test.optional_msg_ext]": {"optional_int32": 456}
72 }
73 )json";
74 upb::Status status;
75 EXPECT_TRUE(upb_JsonDecode(json.data(), json.size(), UPB_UPCAST(ext_msg),
76 m.ptr(), defpool.ptr(), 0, arena.ptr(),
77 status.ptr()))
78 << status.error_message();
79
80 VerifyMessage(ext_msg);
81
82 // Test round-trip through binary format.
83 size_t size;
84 char* serialized =
85 upb_test_TestExtensions_serialize(ext_msg, arena.ptr(), &size);
86 ASSERT_TRUE(serialized != nullptr);
87 ASSERT_GE(size, 0);
88
89 upb_test_TestExtensions* ext_msg2 = upb_test_TestExtensions_parse_ex(
90 serialized, size, upb_DefPool_ExtensionRegistry(defpool.ptr()), 0,
91 arena.ptr());
92 VerifyMessage(ext_msg2);
93
94 // Test round-trip through JSON format.
95 size_t json_size = upb_JsonEncode(UPB_UPCAST(ext_msg), m.ptr(), defpool.ptr(),
96 0, nullptr, 0, status.ptr());
97 char* json_buf =
98 static_cast<char*>(upb_Arena_Malloc(arena.ptr(), json_size + 1));
99 upb_JsonEncode(UPB_UPCAST(ext_msg), m.ptr(), defpool.ptr(), 0, json_buf,
100 json_size + 1, status.ptr());
101 upb_test_TestExtensions* ext_msg3 = upb_test_TestExtensions_new(arena.ptr());
102 EXPECT_TRUE(upb_JsonDecode(json_buf, json_size, UPB_UPCAST(ext_msg3), m.ptr(),
103 defpool.ptr(), 0, arena.ptr(), status.ptr()))
104 << status.error_message();
105 VerifyMessage(ext_msg3);
106
107 // Test setters and mutable accessors
108 upb_test_TestExtensions* ext_msg4 = upb_test_TestExtensions_new(arena.ptr());
109 upb_test_TestExtensions_set_optional_int32_ext(ext_msg4, 123, arena.ptr());
110 protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_int32(
111 upb_test_mutable_optional_msg_ext(ext_msg4, arena.ptr()), 456);
112 VerifyMessage(ext_msg4);
113 }
114
VerifyMessageSet(const upb_test_TestMessageSet * mset_msg)115 void VerifyMessageSet(const upb_test_TestMessageSet* mset_msg) {
116 ASSERT_TRUE(mset_msg != nullptr);
117 bool has = upb_test_MessageSetMember_has_message_set_extension(mset_msg);
118 EXPECT_TRUE(has);
119 if (!has) return;
120 const upb_test_MessageSetMember* member =
121 upb_test_MessageSetMember_message_set_extension(mset_msg);
122 EXPECT_TRUE(member != nullptr);
123 EXPECT_TRUE(upb_test_MessageSetMember_has_optional_int32(member));
124 EXPECT_EQ(234, upb_test_MessageSetMember_optional_int32(member));
125 }
126
TEST(MessageTest,MessageSet)127 TEST(MessageTest, MessageSet) {
128 upb::Arena arena;
129 upb_test_TestMessageSet* ext_msg = upb_test_TestMessageSet_new(arena.ptr());
130
131 EXPECT_FALSE(upb_test_MessageSetMember_has_message_set_extension(ext_msg));
132
133 upb::DefPool defpool;
134 upb::MessageDefPtr m(upb_test_TestMessageSet_getmsgdef(defpool.ptr()));
135 EXPECT_TRUE(m.ptr() != nullptr);
136
137 std::string json = R"json(
138 {
139 "[upb_test.MessageSetMember]": {"optional_int32": 234}
140 }
141 )json";
142 upb::Status status;
143 EXPECT_TRUE(upb_JsonDecode(json.data(), json.size(), UPB_UPCAST(ext_msg),
144 m.ptr(), defpool.ptr(), 0, arena.ptr(),
145 status.ptr()))
146 << status.error_message();
147
148 VerifyMessageSet(ext_msg);
149
150 // Test round-trip through binary format.
151 size_t size;
152 char* serialized =
153 upb_test_TestMessageSet_serialize(ext_msg, arena.ptr(), &size);
154 ASSERT_TRUE(serialized != nullptr);
155 ASSERT_GE(size, 0);
156
157 upb_test_TestMessageSet* ext_msg2 = upb_test_TestMessageSet_parse_ex(
158 serialized, size, upb_DefPool_ExtensionRegistry(defpool.ptr()), 0,
159 arena.ptr());
160 VerifyMessageSet(ext_msg2);
161
162 // Test round-trip through JSON format.
163 size_t json_size = upb_JsonEncode(UPB_UPCAST(ext_msg), m.ptr(), defpool.ptr(),
164 0, nullptr, 0, status.ptr());
165 char* json_buf =
166 static_cast<char*>(upb_Arena_Malloc(arena.ptr(), json_size + 1));
167 upb_JsonEncode(UPB_UPCAST(ext_msg), m.ptr(), defpool.ptr(), 0, json_buf,
168 json_size + 1, status.ptr());
169 upb_test_TestMessageSet* ext_msg3 = upb_test_TestMessageSet_new(arena.ptr());
170 EXPECT_TRUE(upb_JsonDecode(json_buf, json_size, UPB_UPCAST(ext_msg3), m.ptr(),
171 defpool.ptr(), 0, arena.ptr(), status.ptr()))
172 << status.error_message();
173 VerifyMessageSet(ext_msg3);
174 }
175
TEST(MessageTest,UnknownMessageSet)176 TEST(MessageTest, UnknownMessageSet) {
177 static const char data[] = "ABCDE";
178 upb_StringView data_view = upb_StringView_FromString(data);
179 upb::Arena arena;
180 upb_test_FakeMessageSet* fake = upb_test_FakeMessageSet_new(arena.ptr());
181
182 // Add a MessageSet item that is unknown (there is no matching extension in
183 // the .proto file)
184 upb_test_FakeMessageSet_Item* item =
185 upb_test_FakeMessageSet_add_item(fake, arena.ptr());
186 upb_test_FakeMessageSet_Item_set_type_id(item, 12345);
187 upb_test_FakeMessageSet_Item_set_message(item, data_view);
188
189 // Set unknown fields inside the message set to test that we can skip them.
190 upb_test_FakeMessageSet_Item_set_unknown_varint(item, 12345678);
191 upb_test_FakeMessageSet_Item_set_unknown_fixed32(item, 12345678);
192 upb_test_FakeMessageSet_Item_set_unknown_fixed64(item, 12345678);
193 upb_test_FakeMessageSet_Item_set_unknown_bytes(item, data_view);
194 upb_test_FakeMessageSet_Item_mutable_unknowngroup(item, arena.ptr());
195
196 // Round trip through a true MessageSet where this item_id is unknown.
197 size_t size;
198 char* serialized =
199 upb_test_FakeMessageSet_serialize(fake, arena.ptr(), &size);
200 ASSERT_TRUE(serialized != nullptr);
201 ASSERT_GE(size, 0);
202
203 upb::DefPool defpool;
204 upb::MessageDefPtr m(upb_test_TestMessageSet_getmsgdef(defpool.ptr()));
205 EXPECT_TRUE(m.ptr() != nullptr);
206 upb_test_TestMessageSet* message_set = upb_test_TestMessageSet_parse_ex(
207 serialized, size, upb_DefPool_ExtensionRegistry(defpool.ptr()), 0,
208 arena.ptr());
209 ASSERT_TRUE(message_set != nullptr);
210
211 char* serialized2 =
212 upb_test_TestMessageSet_serialize(message_set, arena.ptr(), &size);
213 ASSERT_TRUE(serialized2 != nullptr);
214 ASSERT_GE(size, 0);
215
216 // Parse back into a fake MessageSet and verify that the unknown MessageSet
217 // item was preserved in full (both type_id and message).
218 upb_test_FakeMessageSet* fake2 =
219 upb_test_FakeMessageSet_parse(serialized2, size, arena.ptr());
220 ASSERT_TRUE(fake2 != nullptr);
221
222 const upb_test_FakeMessageSet_Item* const* items =
223 upb_test_FakeMessageSet_item(fake2, &size);
224 ASSERT_EQ(1, size);
225 EXPECT_EQ(12345, upb_test_FakeMessageSet_Item_type_id(items[0]));
226 EXPECT_TRUE(upb_StringView_IsEqual(
227 data_view, upb_test_FakeMessageSet_Item_message(items[0])));
228
229 // The non-MessageSet unknown fields should have been discarded.
230 EXPECT_FALSE(upb_test_FakeMessageSet_Item_has_unknown_varint(items[0]));
231 EXPECT_FALSE(upb_test_FakeMessageSet_Item_has_unknown_fixed32(items[0]));
232 EXPECT_FALSE(upb_test_FakeMessageSet_Item_has_unknown_fixed64(items[0]));
233 EXPECT_FALSE(upb_test_FakeMessageSet_Item_has_unknown_bytes(items[0]));
234 EXPECT_FALSE(upb_test_FakeMessageSet_Item_has_unknowngroup(items[0]));
235 }
236
TEST(MessageTest,Proto2Enum)237 TEST(MessageTest, Proto2Enum) {
238 upb::Arena arena;
239 upb_test_Proto2FakeEnumMessage* fake_msg =
240 upb_test_Proto2FakeEnumMessage_new(arena.ptr());
241
242 upb_test_Proto2FakeEnumMessage_set_optional_enum(fake_msg, 999);
243
244 int32_t* vals = upb_test_Proto2FakeEnumMessage_resize_repeated_enum(
245 fake_msg, 6, arena.ptr());
246 vals[0] = upb_test_Proto2EnumMessage_ZERO;
247 vals[1] = 7; // Unknown small.
248 vals[2] = upb_test_Proto2EnumMessage_SMALL;
249 vals[3] = 888; // Unknown large.
250 vals[4] = upb_test_Proto2EnumMessage_LARGE;
251 vals[5] = upb_test_Proto2EnumMessage_NEGATIVE;
252
253 vals = upb_test_Proto2FakeEnumMessage_resize_packed_enum(fake_msg, 6,
254 arena.ptr());
255 vals[0] = upb_test_Proto2EnumMessage_ZERO;
256 vals[1] = 7; // Unknown small.
257 vals[2] = upb_test_Proto2EnumMessage_SMALL;
258 vals[3] = 888; // Unknown large.
259 vals[4] = upb_test_Proto2EnumMessage_LARGE;
260 vals[5] = upb_test_Proto2EnumMessage_NEGATIVE;
261
262 size_t size;
263 char* pb =
264 upb_test_Proto2FakeEnumMessage_serialize(fake_msg, arena.ptr(), &size);
265
266 // Parsing as enums puts unknown values into unknown fields.
267 upb_test_Proto2EnumMessage* enum_msg =
268 upb_test_Proto2EnumMessage_parse(pb, size, arena.ptr());
269 ASSERT_TRUE(enum_msg != nullptr);
270
271 EXPECT_EQ(false, upb_test_Proto2EnumMessage_has_optional_enum(enum_msg));
272 const int32_t* vals_const =
273 upb_test_Proto2EnumMessage_repeated_enum(enum_msg, &size);
274 EXPECT_EQ(4, size); // Two unknown values moved to the unknown field set.
275
276 // Parsing back into the fake message shows the original data, except the
277 // repeated enum is rearranged.
278 pb = upb_test_Proto2EnumMessage_serialize(enum_msg, arena.ptr(), &size);
279 upb_test_Proto2FakeEnumMessage* fake_msg2 =
280 upb_test_Proto2FakeEnumMessage_parse(pb, size, arena.ptr());
281 ASSERT_TRUE(fake_msg2 != nullptr);
282
283 EXPECT_EQ(true, upb_test_Proto2FakeEnumMessage_has_optional_enum(fake_msg2));
284 EXPECT_EQ(999, upb_test_Proto2FakeEnumMessage_optional_enum(fake_msg2));
285
286 int32_t expected[] = {
287 upb_test_Proto2EnumMessage_ZERO,
288 upb_test_Proto2EnumMessage_SMALL,
289 upb_test_Proto2EnumMessage_LARGE,
290 upb_test_Proto2EnumMessage_NEGATIVE,
291 7,
292 888,
293 };
294
295 vals_const = upb_test_Proto2FakeEnumMessage_repeated_enum(fake_msg2, &size);
296 EXPECT_EQ(6, size);
297 EXPECT_THAT(std::vector<int32_t>(vals_const, vals_const + size),
298 ::testing::ElementsAreArray(expected));
299
300 vals_const = upb_test_Proto2FakeEnumMessage_packed_enum(fake_msg2, &size);
301 EXPECT_EQ(6, size);
302 EXPECT_THAT(std::vector<int32_t>(vals_const, vals_const + size),
303 ::testing::ElementsAreArray(expected));
304 }
305
TEST(MessageTest,TestBadUTF8)306 TEST(MessageTest, TestBadUTF8) {
307 upb::Arena arena;
308 std::string serialized("r\x03\xed\xa0\x81");
309 EXPECT_EQ(nullptr, protobuf_test_messages_proto3_TestAllTypesProto3_parse(
310 serialized.data(), serialized.size(), arena.ptr()));
311 }
312
TEST(MessageTest,DecodeRequiredFieldsTopLevelMessage)313 TEST(MessageTest, DecodeRequiredFieldsTopLevelMessage) {
314 upb::Arena arena;
315 upb_test_TestRequiredFields* test_msg;
316 upb_test_EmptyMessage* empty_msg;
317
318 // Succeeds, because we did not request required field checks.
319 test_msg = upb_test_TestRequiredFields_parse(nullptr, 0, arena.ptr());
320 EXPECT_NE(nullptr, test_msg);
321
322 // Fails, because required fields are missing.
323 EXPECT_EQ(kUpb_DecodeStatus_MissingRequired,
324 upb_Decode(nullptr, 0, UPB_UPCAST(test_msg),
325 &upb_0test__TestRequiredFields_msg_init, nullptr,
326 kUpb_DecodeOption_CheckRequired, arena.ptr()));
327
328 upb_test_TestRequiredFields_set_required_int32(test_msg, 1);
329 size_t size;
330 char* serialized =
331 upb_test_TestRequiredFields_serialize(test_msg, arena.ptr(), &size);
332 ASSERT_TRUE(serialized != nullptr);
333 EXPECT_NE(0, size);
334
335 // Fails, but the code path is slightly different because the serialized
336 // payload is not empty.
337 EXPECT_EQ(kUpb_DecodeStatus_MissingRequired,
338 upb_Decode(serialized, size, UPB_UPCAST(test_msg),
339 &upb_0test__TestRequiredFields_msg_init, nullptr,
340 kUpb_DecodeOption_CheckRequired, arena.ptr()));
341
342 empty_msg = upb_test_EmptyMessage_new(arena.ptr());
343 upb_test_TestRequiredFields_set_required_int32(test_msg, 1);
344 upb_test_TestRequiredFields_set_required_int64(test_msg, 2);
345 upb_test_TestRequiredFields_set_required_message(test_msg, empty_msg);
346
347 // Succeeds, because required fields are present (though not in the input).
348 EXPECT_EQ(kUpb_DecodeStatus_Ok,
349 upb_Decode(nullptr, 0, UPB_UPCAST(test_msg),
350 &upb_0test__TestRequiredFields_msg_init, nullptr,
351 kUpb_DecodeOption_CheckRequired, arena.ptr()));
352
353 // Serialize a complete payload.
354 serialized =
355 upb_test_TestRequiredFields_serialize(test_msg, arena.ptr(), &size);
356 ASSERT_TRUE(serialized != nullptr);
357 EXPECT_NE(0, size);
358
359 upb_test_TestRequiredFields* test_msg2 = upb_test_TestRequiredFields_parse_ex(
360 serialized, size, nullptr, kUpb_DecodeOption_CheckRequired, arena.ptr());
361 EXPECT_NE(nullptr, test_msg2);
362
363 // When we add an incomplete sub-message, this is not flagged by the parser.
364 // This makes parser checking unsuitable for MergeFrom().
365 upb_test_TestRequiredFields_set_optional_message(
366 test_msg2, upb_test_TestRequiredFields_new(arena.ptr()));
367 EXPECT_EQ(kUpb_DecodeStatus_Ok,
368 upb_Decode(serialized, size, UPB_UPCAST(test_msg2),
369 &upb_0test__TestRequiredFields_msg_init, nullptr,
370 kUpb_DecodeOption_CheckRequired, arena.ptr()));
371 }
372
TEST(MessageTest,DecodeRequiredFieldsSubMessage)373 TEST(MessageTest, DecodeRequiredFieldsSubMessage) {
374 upb::Arena arena;
375 upb_test_TestRequiredFields* test_msg =
376 upb_test_TestRequiredFields_new(arena.ptr());
377 upb_test_SubMessageHasRequired* sub_msg =
378 upb_test_SubMessageHasRequired_new(arena.ptr());
379 upb_test_EmptyMessage* empty_msg = upb_test_EmptyMessage_new(arena.ptr());
380
381 upb_test_SubMessageHasRequired_set_optional_message(sub_msg, test_msg);
382 size_t size;
383 char* serialized =
384 upb_test_SubMessageHasRequired_serialize(sub_msg, arena.ptr(), &size);
385 EXPECT_NE(0, size);
386
387 // No parse error when parsing normally.
388 EXPECT_NE(nullptr, upb_test_SubMessageHasRequired_parse(serialized, size,
389 arena.ptr()));
390
391 // Parse error when verifying required fields, due to incomplete sub-message.
392 EXPECT_EQ(nullptr, upb_test_SubMessageHasRequired_parse_ex(
393 serialized, size, nullptr,
394 kUpb_DecodeOption_CheckRequired, arena.ptr()));
395
396 upb_test_TestRequiredFields_set_required_int32(test_msg, 1);
397 upb_test_TestRequiredFields_set_required_int64(test_msg, 2);
398 upb_test_TestRequiredFields_set_required_message(test_msg, empty_msg);
399
400 serialized =
401 upb_test_SubMessageHasRequired_serialize(sub_msg, arena.ptr(), &size);
402 EXPECT_NE(0, size);
403
404 // No parse error; sub-message now is complete.
405 EXPECT_NE(nullptr, upb_test_SubMessageHasRequired_parse_ex(
406 serialized, size, nullptr,
407 kUpb_DecodeOption_CheckRequired, arena.ptr()));
408 }
409
TEST(MessageTest,EncodeRequiredFields)410 TEST(MessageTest, EncodeRequiredFields) {
411 upb::Arena arena;
412 upb_test_TestRequiredFields* test_msg =
413 upb_test_TestRequiredFields_new(arena.ptr());
414
415 // Succeeds, we didn't ask for required field checking.
416 size_t size;
417 char* serialized =
418 upb_test_TestRequiredFields_serialize_ex(test_msg, 0, arena.ptr(), &size);
419 ASSERT_TRUE(serialized != nullptr);
420 EXPECT_EQ(size, 0);
421
422 // Fails, we asked for required field checking but the required field is
423 // missing.
424 serialized = upb_test_TestRequiredFields_serialize_ex(
425 test_msg, kUpb_EncodeOption_CheckRequired, arena.ptr(), &size);
426 ASSERT_TRUE(serialized == nullptr);
427
428 // Fails, some required fields are present but not others.
429 upb_test_TestRequiredFields_set_required_int32(test_msg, 1);
430 serialized = upb_test_TestRequiredFields_serialize_ex(
431 test_msg, kUpb_EncodeOption_CheckRequired, arena.ptr(), &size);
432 ASSERT_TRUE(serialized == nullptr);
433
434 // Succeeds, all required fields are set.
435 upb_test_EmptyMessage* empty_msg = upb_test_EmptyMessage_new(arena.ptr());
436 upb_test_TestRequiredFields_set_required_int64(test_msg, 2);
437 upb_test_TestRequiredFields_set_required_message(test_msg, empty_msg);
438 serialized = upb_test_TestRequiredFields_serialize_ex(
439 test_msg, kUpb_EncodeOption_CheckRequired, arena.ptr(), &size);
440 ASSERT_TRUE(serialized != nullptr);
441 }
442
TEST(MessageTest,MaxRequiredFields)443 TEST(MessageTest, MaxRequiredFields) {
444 upb::Arena arena;
445 upb_test_TestMaxRequiredFields* test_msg =
446 upb_test_TestMaxRequiredFields_new(arena.ptr());
447
448 // Fails, we asked for required field checking but the required field is
449 // missing.
450 size_t size;
451 char* serialized = upb_test_TestMaxRequiredFields_serialize_ex(
452 test_msg, kUpb_EncodeOption_CheckRequired, arena.ptr(), &size);
453 ASSERT_TRUE(serialized == nullptr);
454
455 upb::DefPool defpool;
456 upb::MessageDefPtr m(upb_test_TestMaxRequiredFields_getmsgdef(defpool.ptr()));
457 upb_MessageValue val;
458 val.int32_val = 1;
459 for (int i = 1; i <= 61; i++) {
460 upb::FieldDefPtr f = m.FindFieldByNumber(i);
461 ASSERT_TRUE(f);
462 upb_Message_SetFieldByDef(UPB_UPCAST(test_msg), f.ptr(), val, arena.ptr());
463 }
464
465 // Fails, field 63 still isn't set.
466 serialized = upb_test_TestMaxRequiredFields_serialize_ex(
467 test_msg, kUpb_EncodeOption_CheckRequired, arena.ptr(), &size);
468 ASSERT_TRUE(serialized == nullptr);
469
470 // Succeeds, all required fields are set.
471 upb::FieldDefPtr f = m.FindFieldByNumber(62);
472 ASSERT_TRUE(f);
473 upb_Message_SetFieldByDef(UPB_UPCAST(test_msg), f.ptr(), val, arena.ptr());
474 serialized = upb_test_TestMaxRequiredFields_serialize_ex(
475 test_msg, kUpb_EncodeOption_CheckRequired, arena.ptr(), &size);
476 ASSERT_TRUE(serialized != nullptr);
477 }
478
TEST(MessageTest,MapField)479 TEST(MessageTest, MapField) {
480 upb::Arena arena;
481 upb_test_TestMapFieldExtra* test_msg_extra =
482 upb_test_TestMapFieldExtra_new(arena.ptr());
483
484 ASSERT_TRUE(upb_test_TestMapFieldExtra_map_field_set(
485 test_msg_extra, 0, upb_test_TestMapFieldExtra_THREE, arena.ptr()));
486
487 size_t size;
488 char* serialized = upb_test_TestMapFieldExtra_serialize_ex(
489 test_msg_extra, 0, arena.ptr(), &size);
490 ASSERT_NE(nullptr, serialized);
491 ASSERT_NE(0, size);
492
493 upb_test_TestMapField* test_msg =
494 upb_test_TestMapField_parse(serialized, size, arena.ptr());
495 ASSERT_NE(nullptr, test_msg);
496
497 ASSERT_FALSE(upb_test_TestMapField_map_field_get(test_msg, 0, nullptr));
498 serialized =
499 upb_test_TestMapField_serialize_ex(test_msg, 0, arena.ptr(), &size);
500 ASSERT_NE(0, size);
501 // parse into second instance
502 upb_test_TestMapFieldExtra* test_msg_extra2 =
503 upb_test_TestMapFieldExtra_parse(serialized, size, arena.ptr());
504 ASSERT_TRUE(
505 upb_test_TestMapFieldExtra_map_field_get(test_msg_extra2, 0, nullptr));
506 }
507
TEST(MessageTest,Freeze)508 TEST(MessageTest, Freeze) {
509 const upb_MiniTable* m = &upb_0test__TestFreeze_msg_init;
510 upb::Arena arena;
511
512 {
513 upb_test_TestFreeze* raw = upb_test_TestFreeze_new(arena.ptr());
514 upb_Message* msg = UPB_UPCAST(raw);
515 ASSERT_FALSE(upb_Message_IsFrozen(msg));
516 upb_Message_Freeze(msg, m);
517 ASSERT_TRUE(upb_Message_IsFrozen(msg));
518 }
519 {
520 upb_test_TestFreeze* raw = upb_test_TestFreeze_new(arena.ptr());
521 upb_Message* msg = UPB_UPCAST(raw);
522 size_t size;
523 upb_Array* arr = _upb_test_TestFreeze_array_int_mutable_upb_array(
524 raw, &size, arena.ptr());
525 ASSERT_NE(arr, nullptr);
526 ASSERT_EQ(size, 0);
527 ASSERT_FALSE(upb_Array_IsFrozen(arr));
528 upb_Map* map =
529 _upb_test_TestFreeze_map_int_mutable_upb_map(raw, arena.ptr());
530 ASSERT_NE(map, nullptr);
531 ASSERT_FALSE(upb_Map_IsFrozen(map));
532 upb_test_TestFreeze* nest = upb_test_TestFreeze_new(arena.ptr());
533 upb_test_set_nest(raw, nest, arena.ptr());
534 ASSERT_FALSE(upb_Message_IsFrozen(UPB_UPCAST(nest)));
535
536 upb_Message_Freeze(msg, m);
537 ASSERT_TRUE(upb_Message_IsFrozen(msg));
538 ASSERT_TRUE(upb_Array_IsFrozen(arr));
539 ASSERT_TRUE(upb_Map_IsFrozen(map));
540 ASSERT_TRUE(upb_Message_IsFrozen(UPB_UPCAST(nest)));
541 }
542 {
543 upb_test_TestFreeze* raw = upb_test_TestFreeze_new(arena.ptr());
544 upb_Message* msg = UPB_UPCAST(raw);
545 size_t size;
546 upb_Array* arr = _upb_test_TestFreeze_array_int_mutable_upb_array(
547 raw, &size, arena.ptr());
548 ASSERT_NE(arr, nullptr);
549 ASSERT_EQ(size, 0);
550 ASSERT_FALSE(upb_Array_IsFrozen(arr));
551 upb_Map* map =
552 _upb_test_TestFreeze_map_int_mutable_upb_map(raw, arena.ptr());
553 ASSERT_NE(map, nullptr);
554 ASSERT_FALSE(upb_Map_IsFrozen(map));
555 upb_test_TestFreeze* nest = upb_test_TestFreeze_new(arena.ptr());
556 upb_test_set_nest(raw, nest, arena.ptr());
557 ASSERT_FALSE(upb_Message_IsFrozen(UPB_UPCAST(nest)));
558
559 upb_Message_Freeze(UPB_UPCAST(nest), m);
560 ASSERT_FALSE(upb_Message_IsFrozen(msg));
561 ASSERT_FALSE(upb_Array_IsFrozen(arr));
562 ASSERT_FALSE(upb_Map_IsFrozen(map));
563 ASSERT_TRUE(upb_Message_IsFrozen(UPB_UPCAST(nest)));
564
565 const upb_MiniTableField* fa = upb_MiniTable_FindFieldByNumber(m, 20);
566 const upb_MiniTable* ma = upb_MiniTable_SubMessage(m, fa);
567 upb_Array_Freeze(arr, ma);
568 ASSERT_FALSE(upb_Message_IsFrozen(msg));
569 ASSERT_TRUE(upb_Array_IsFrozen(arr));
570 ASSERT_FALSE(upb_Map_IsFrozen(map));
571 ASSERT_TRUE(upb_Message_IsFrozen(UPB_UPCAST(nest)));
572
573 const upb_MiniTableField* fm = upb_MiniTable_FindFieldByNumber(m, 10);
574 const upb_MiniTable* mm = upb_MiniTable_SubMessage(m, fm);
575 upb_Map_Freeze(map, mm);
576 ASSERT_FALSE(upb_Message_IsFrozen(msg));
577 ASSERT_TRUE(upb_Array_IsFrozen(arr));
578 ASSERT_TRUE(upb_Map_IsFrozen(map));
579 ASSERT_TRUE(upb_Message_IsFrozen(UPB_UPCAST(nest)));
580 }
581 }
582