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 /* Test of mini table accessors.
9 *
10 * Messages are created and mutated using generated code, and then
11 * accessed through reflective APIs exposed through mini table accessors.
12 */
13
14 #include "upb/message/promote.h"
15
16 #include <string.h>
17
18 #include <cstddef>
19 #include <cstdint>
20 #include <string>
21
22 #include <gtest/gtest.h>
23 #include "upb/base/descriptor_constants.h"
24 #include "upb/base/status.h"
25 #include "upb/base/string_view.h"
26 #include "upb/base/upcast.h"
27 #include "upb/mem/arena.h"
28 #include "upb/mem/arena.hpp"
29 #include "upb/message/accessors.h"
30 #include "upb/message/array.h"
31 #include "upb/message/copy.h"
32 #include "upb/message/internal/extension.h"
33 #include "upb/message/internal/message.h"
34 #include "upb/message/map.h"
35 #include "upb/message/message.h"
36 #include "upb/message/tagged_ptr.h"
37 #include "upb/mini_descriptor/decode.h"
38 #include "upb/mini_descriptor/internal/encode.hpp"
39 #include "upb/mini_descriptor/internal/modifiers.h"
40 #include "upb/mini_descriptor/link.h"
41 #include "upb/mini_table/extension.h"
42 #include "upb/mini_table/field.h"
43 #include "upb/mini_table/message.h"
44 #include "upb/test/test.upb.h"
45 #include "upb/test/test.upb_minitable.h"
46 #include "upb/wire/decode.h"
47 #include "upb/wire/encode.h"
48
49 namespace {
50
TEST(GeneratedCode,FindUnknown)51 TEST(GeneratedCode, FindUnknown) {
52 upb_Arena* arena = upb_Arena_New();
53 upb_test_ModelWithExtensions* msg = upb_test_ModelWithExtensions_new(arena);
54 upb_test_ModelWithExtensions_set_random_int32(msg, 10);
55 upb_test_ModelWithExtensions_set_random_name(
56 msg, upb_StringView_FromString("Hello"));
57
58 upb_test_ModelExtension1* extension1 = upb_test_ModelExtension1_new(arena);
59 upb_test_ModelExtension1_set_str(extension1,
60 upb_StringView_FromString("World"));
61
62 upb_test_ModelExtension1_set_model_ext(msg, extension1, arena);
63
64 size_t serialized_size;
65 char* serialized =
66 upb_test_ModelWithExtensions_serialize(msg, arena, &serialized_size);
67
68 upb_test_EmptyMessageWithExtensions* base_msg =
69 upb_test_EmptyMessageWithExtensions_parse(serialized, serialized_size,
70 arena);
71
72 upb_FindUnknownRet result = upb_Message_FindUnknown(
73 UPB_UPCAST(base_msg),
74 upb_MiniTableExtension_Number(&upb_test_ModelExtension1_model_ext_ext),
75 0);
76 EXPECT_EQ(kUpb_FindUnknown_Ok, result.status);
77
78 result = upb_Message_FindUnknown(
79 UPB_UPCAST(base_msg),
80 upb_MiniTableExtension_Number(&upb_test_ModelExtension2_model_ext_ext),
81 0);
82 EXPECT_EQ(kUpb_FindUnknown_NotPresent, result.status);
83
84 upb_Arena_Free(arena);
85 }
86
TEST(GeneratedCode,Extensions)87 TEST(GeneratedCode, Extensions) {
88 upb_Arena* arena = upb_Arena_New();
89 upb_test_ModelWithExtensions* msg = upb_test_ModelWithExtensions_new(arena);
90 upb_test_ModelWithExtensions_set_random_int32(msg, 10);
91 upb_test_ModelWithExtensions_set_random_name(
92 msg, upb_StringView_FromString("Hello"));
93
94 upb_test_ModelExtension1* extension1 = upb_test_ModelExtension1_new(arena);
95 upb_test_ModelExtension1_set_str(extension1,
96 upb_StringView_FromString("World"));
97
98 upb_test_ModelExtension2* extension2 = upb_test_ModelExtension2_new(arena);
99 upb_test_ModelExtension2_set_i(extension2, 5);
100
101 upb_test_ModelExtension2* extension3 = upb_test_ModelExtension2_new(arena);
102 upb_test_ModelExtension2_set_i(extension3, 6);
103
104 upb_test_ModelExtension2* extension4 = upb_test_ModelExtension2_new(arena);
105 upb_test_ModelExtension2_set_i(extension4, 7);
106
107 upb_test_ModelExtension2* extension5 = upb_test_ModelExtension2_new(arena);
108 upb_test_ModelExtension2_set_i(extension5, 8);
109
110 upb_test_ModelExtension2* extension6 = upb_test_ModelExtension2_new(arena);
111 upb_test_ModelExtension2_set_i(extension6, 9);
112
113 // Set many extensions, to exercise code paths that involve reallocating the
114 // extensions and unknown fields array.
115 upb_test_ModelExtension1_set_model_ext(msg, extension1, arena);
116 upb_test_ModelExtension2_set_model_ext(msg, extension2, arena);
117 upb_test_ModelExtension2_set_model_ext_2(msg, extension3, arena);
118 upb_test_ModelExtension2_set_model_ext_3(msg, extension4, arena);
119 upb_test_ModelExtension2_set_model_ext_4(msg, extension5, arena);
120 upb_test_ModelExtension2_set_model_ext_5(msg, extension6, arena);
121
122 size_t serialized_size;
123 char* serialized =
124 upb_test_ModelWithExtensions_serialize(msg, arena, &serialized_size);
125
126 upb_test_ModelExtension1* ext1;
127 upb_test_ModelExtension2* ext2;
128 upb_GetExtension_Status promote_status;
129 upb_MessageValue value;
130
131 // Test known GetExtension 1
132 promote_status = upb_Message_GetOrPromoteExtension(
133 UPB_UPCAST(msg), &upb_test_ModelExtension1_model_ext_ext, 0, arena,
134 &value);
135 ext1 = (upb_test_ModelExtension1*)value.msg_val;
136 EXPECT_EQ(kUpb_GetExtension_Ok, promote_status);
137 EXPECT_TRUE(upb_StringView_IsEqual(upb_StringView_FromString("World"),
138 upb_test_ModelExtension1_str(ext1)));
139
140 // Test known GetExtension 2
141 promote_status = upb_Message_GetOrPromoteExtension(
142 UPB_UPCAST(msg), &upb_test_ModelExtension2_model_ext_ext, 0, arena,
143 &value);
144 ext2 = (upb_test_ModelExtension2*)value.msg_val;
145 EXPECT_EQ(kUpb_GetExtension_Ok, promote_status);
146 EXPECT_EQ(5, upb_test_ModelExtension2_i(ext2));
147
148 // Test known GetExtension 3
149 promote_status = upb_Message_GetOrPromoteExtension(
150 UPB_UPCAST(msg), &upb_test_ModelExtension2_model_ext_2_ext, 0, arena,
151 &value);
152 ext2 = (upb_test_ModelExtension2*)value.msg_val;
153 EXPECT_EQ(kUpb_GetExtension_Ok, promote_status);
154 EXPECT_EQ(6, upb_test_ModelExtension2_i(ext2));
155
156 // Test known GetExtension 4
157 promote_status = upb_Message_GetOrPromoteExtension(
158 UPB_UPCAST(msg), &upb_test_ModelExtension2_model_ext_3_ext, 0, arena,
159 &value);
160 ext2 = (upb_test_ModelExtension2*)value.msg_val;
161 EXPECT_EQ(kUpb_GetExtension_Ok, promote_status);
162 EXPECT_EQ(7, upb_test_ModelExtension2_i(ext2));
163
164 // Test known GetExtension 5
165 promote_status = upb_Message_GetOrPromoteExtension(
166 UPB_UPCAST(msg), &upb_test_ModelExtension2_model_ext_4_ext, 0, arena,
167 &value);
168 ext2 = (upb_test_ModelExtension2*)value.msg_val;
169 EXPECT_EQ(kUpb_GetExtension_Ok, promote_status);
170 EXPECT_EQ(8, upb_test_ModelExtension2_i(ext2));
171
172 // Test known GetExtension 6
173 promote_status = upb_Message_GetOrPromoteExtension(
174 UPB_UPCAST(msg), &upb_test_ModelExtension2_model_ext_5_ext, 0, arena,
175 &value);
176 ext2 = (upb_test_ModelExtension2*)value.msg_val;
177 EXPECT_EQ(kUpb_GetExtension_Ok, promote_status);
178 EXPECT_EQ(9, upb_test_ModelExtension2_i(ext2));
179
180 upb_test_EmptyMessageWithExtensions* base_msg =
181 upb_test_EmptyMessageWithExtensions_parse(serialized, serialized_size,
182 arena);
183
184 // Get unknown extension bytes before promotion.
185 size_t start_len;
186 upb_Message_GetUnknown(UPB_UPCAST(base_msg), &start_len);
187 EXPECT_GT(start_len, 0);
188 EXPECT_EQ(0, upb_Message_ExtensionCount(UPB_UPCAST(base_msg)));
189
190 // Test unknown GetExtension.
191 promote_status = upb_Message_GetOrPromoteExtension(
192 UPB_UPCAST(base_msg), &upb_test_ModelExtension1_model_ext_ext, 0, arena,
193 &value);
194 ext1 = (upb_test_ModelExtension1*)value.msg_val;
195 EXPECT_EQ(kUpb_GetExtension_Ok, promote_status);
196 EXPECT_TRUE(upb_StringView_IsEqual(upb_StringView_FromString("World"),
197 upb_test_ModelExtension1_str(ext1)));
198
199 // Test unknown GetExtension.
200 promote_status = upb_Message_GetOrPromoteExtension(
201 UPB_UPCAST(base_msg), &upb_test_ModelExtension2_model_ext_ext, 0, arena,
202 &value);
203 ext2 = (upb_test_ModelExtension2*)value.msg_val;
204 EXPECT_EQ(kUpb_GetExtension_Ok, promote_status);
205 EXPECT_EQ(5, upb_test_ModelExtension2_i(ext2));
206
207 // Test unknown GetExtension.
208 promote_status = upb_Message_GetOrPromoteExtension(
209 UPB_UPCAST(base_msg), &upb_test_ModelExtension2_model_ext_2_ext, 0, arena,
210 &value);
211 ext2 = (upb_test_ModelExtension2*)value.msg_val;
212 EXPECT_EQ(kUpb_GetExtension_Ok, promote_status);
213 EXPECT_EQ(6, upb_test_ModelExtension2_i(ext2));
214
215 // Test unknown GetExtension.
216 promote_status = upb_Message_GetOrPromoteExtension(
217 UPB_UPCAST(base_msg), &upb_test_ModelExtension2_model_ext_3_ext, 0, arena,
218 &value);
219 ext2 = (upb_test_ModelExtension2*)value.msg_val;
220 EXPECT_EQ(kUpb_GetExtension_Ok, promote_status);
221 EXPECT_EQ(7, upb_test_ModelExtension2_i(ext2));
222
223 // Test unknown GetExtension.
224 promote_status = upb_Message_GetOrPromoteExtension(
225 UPB_UPCAST(base_msg), &upb_test_ModelExtension2_model_ext_4_ext, 0, arena,
226 &value);
227 ext2 = (upb_test_ModelExtension2*)value.msg_val;
228 EXPECT_EQ(kUpb_GetExtension_Ok, promote_status);
229 EXPECT_EQ(8, upb_test_ModelExtension2_i(ext2));
230
231 // Test unknown GetExtension.
232 promote_status = upb_Message_GetOrPromoteExtension(
233 UPB_UPCAST(base_msg), &upb_test_ModelExtension2_model_ext_5_ext, 0, arena,
234 &value);
235 ext2 = (upb_test_ModelExtension2*)value.msg_val;
236 EXPECT_EQ(kUpb_GetExtension_Ok, promote_status);
237 EXPECT_EQ(9, upb_test_ModelExtension2_i(ext2));
238
239 size_t end_len;
240 upb_Message_GetUnknown(UPB_UPCAST(base_msg), &end_len);
241 EXPECT_LT(end_len, start_len);
242 EXPECT_EQ(6, upb_Message_ExtensionCount(UPB_UPCAST(base_msg)));
243
244 upb_Arena_Free(arena);
245 }
246
247 // Create a minitable to mimic ModelWithSubMessages with unlinked subs
248 // to lazily promote unknowns after parsing.
CreateMiniTableWithEmptySubTables(upb_Arena * arena)249 upb_MiniTable* CreateMiniTableWithEmptySubTables(upb_Arena* arena) {
250 upb::MtDataEncoder e;
251 e.StartMessage(0);
252 e.PutField(kUpb_FieldType_Int32, 4, 0);
253 e.PutField(kUpb_FieldType_Message, 5, 0);
254 e.PutField(kUpb_FieldType_Message, 6, kUpb_FieldModifier_IsRepeated);
255
256 upb_Status status;
257 upb_Status_Clear(&status);
258 upb_MiniTable* table =
259 upb_MiniTable_Build(e.data().data(), e.data().size(), arena, &status);
260 EXPECT_EQ(status.ok, true);
261 return table;
262 }
263
CreateMapEntryMiniTable(upb_Arena * arena)264 upb_MiniTable* CreateMapEntryMiniTable(upb_Arena* arena) {
265 upb::MtDataEncoder e;
266 e.EncodeMap(kUpb_FieldType_Int32, kUpb_FieldType_Message, 0, 0);
267 upb_Status status;
268 upb_Status_Clear(&status);
269 upb_MiniTable* table =
270 upb_MiniTable_Build(e.data().data(), e.data().size(), arena, &status);
271 EXPECT_EQ(status.ok, true);
272 return table;
273 }
274
275 // Create a minitable to mimic ModelWithMaps with unlinked subs
276 // to lazily promote unknowns after parsing.
CreateMiniTableWithEmptySubTablesForMaps(upb_Arena * arena)277 upb_MiniTable* CreateMiniTableWithEmptySubTablesForMaps(upb_Arena* arena) {
278 upb::MtDataEncoder e;
279 e.StartMessage(0);
280 e.PutField(kUpb_FieldType_Int32, 1, 0);
281 e.PutField(kUpb_FieldType_Message, 3, kUpb_FieldModifier_IsRepeated);
282 e.PutField(kUpb_FieldType_Message, 5, kUpb_FieldModifier_IsRepeated);
283
284 upb_Status status;
285 upb_Status_Clear(&status);
286 upb_MiniTable* table =
287 upb_MiniTable_Build(e.data().data(), e.data().size(), arena, &status);
288
289 // Field 5 corresponds to ModelWithMaps.map_sm.
290 upb_MiniTableField* map_field = const_cast<upb_MiniTableField*>(
291 upb_MiniTable_FindFieldByNumber(table, 5));
292 EXPECT_NE(map_field, nullptr);
293 upb_MiniTable* sub_table = CreateMapEntryMiniTable(arena);
294 upb_MiniTable_SetSubMessage(table, map_field, sub_table);
295 EXPECT_EQ(status.ok, true);
296 return table;
297 }
298
CheckReserialize(const upb_Message * msg,const upb_MiniTable * mini_table,upb_Arena * arena,char * serialized,size_t serialized_size)299 void CheckReserialize(const upb_Message* msg, const upb_MiniTable* mini_table,
300 upb_Arena* arena, char* serialized,
301 size_t serialized_size) {
302 // We can safely encode the "empty" message. We expect to get the same bytes
303 // out as were parsed.
304 size_t reserialized_size;
305 char* reserialized;
306 upb_EncodeStatus encode_status =
307 upb_Encode(msg, mini_table, kUpb_EncodeOption_Deterministic, arena,
308 &reserialized, &reserialized_size);
309 EXPECT_EQ(encode_status, kUpb_EncodeStatus_Ok);
310 EXPECT_EQ(reserialized_size, serialized_size);
311 EXPECT_EQ(0, memcmp(reserialized, serialized, serialized_size));
312
313 // We should get the same result if we copy+reserialize.
314 upb_Message* clone = upb_Message_DeepClone(msg, mini_table, arena);
315 encode_status = upb_Encode(clone, mini_table, kUpb_EncodeOption_Deterministic,
316 arena, &reserialized, &reserialized_size);
317 EXPECT_EQ(encode_status, kUpb_EncodeStatus_Ok);
318 EXPECT_EQ(reserialized_size, serialized_size);
319 EXPECT_EQ(0, memcmp(reserialized, serialized, serialized_size));
320 }
321
TEST(GeneratedCode,PromoteUnknownMessage)322 TEST(GeneratedCode, PromoteUnknownMessage) {
323 upb::Arena arena;
324 upb_test_ModelWithSubMessages* input_msg =
325 upb_test_ModelWithSubMessages_new(arena.ptr());
326 upb_test_ModelWithExtensions* sub_message =
327 upb_test_ModelWithExtensions_new(arena.ptr());
328 upb_test_ModelWithSubMessages_set_id(input_msg, 11);
329 upb_test_ModelWithExtensions_set_random_int32(sub_message, 12);
330 upb_test_ModelWithSubMessages_set_optional_child(input_msg, sub_message);
331 size_t serialized_size;
332 char* serialized = upb_test_ModelWithSubMessages_serialize(
333 input_msg, arena.ptr(), &serialized_size);
334
335 upb_MiniTable* mini_table = CreateMiniTableWithEmptySubTables(arena.ptr());
336 upb_DecodeStatus decode_status;
337
338 // If we parse without allowing unlinked objects, the parse will fail.
339 // TODO: re-enable this test once the old method of tree shaking is
340 // removed
341 // upb_Message* fail_msg = _upb_Message_New(mini_table, arena.ptr());
342 // decode_status =
343 // upb_Decode(serialized, serialized_size, fail_msg, mini_table, nullptr,
344 // 0,
345 // arena.ptr());
346 // EXPECT_EQ(decode_status, kUpb_DecodeStatus_UnlinkedSubMessage);
347
348 // if we parse while allowing unlinked objects, the parse will succeed.
349 upb_Message* msg = _upb_Message_New(mini_table, arena.ptr());
350 decode_status =
351 upb_Decode(serialized, serialized_size, msg, mini_table, nullptr,
352 kUpb_DecodeOption_ExperimentalAllowUnlinked, arena.ptr());
353 EXPECT_EQ(decode_status, kUpb_DecodeStatus_Ok);
354
355 CheckReserialize(msg, mini_table, arena.ptr(), serialized, serialized_size);
356
357 // We can encode the "empty" message and get the same output bytes.
358 size_t reserialized_size;
359 char* reserialized;
360 upb_EncodeStatus encode_status = upb_Encode(
361 msg, mini_table, 0, arena.ptr(), &reserialized, &reserialized_size);
362 EXPECT_EQ(encode_status, kUpb_EncodeStatus_Ok);
363 EXPECT_EQ(reserialized_size, serialized_size);
364 EXPECT_EQ(0, memcmp(reserialized, serialized, serialized_size));
365
366 // Int32 field is present, as normal.
367 int32_t val = upb_Message_GetInt32(
368 msg, upb_MiniTable_FindFieldByNumber(mini_table, 4), 0);
369 EXPECT_EQ(val, 11);
370
371 // Unlinked sub-message is present, but getting the value returns NULL.
372 const upb_MiniTableField* submsg_field =
373 upb_MiniTable_FindFieldByNumber(mini_table, 5);
374 ASSERT_TRUE(submsg_field != nullptr);
375 EXPECT_TRUE(upb_Message_HasBaseField(msg, submsg_field));
376 upb_TaggedMessagePtr tagged =
377 upb_Message_GetTaggedMessagePtr(msg, submsg_field, nullptr);
378 EXPECT_TRUE(upb_TaggedMessagePtr_IsEmpty(tagged));
379
380 // Update mini table and promote unknown to a message.
381 EXPECT_TRUE(
382 upb_MiniTable_SetSubMessage(mini_table, (upb_MiniTableField*)submsg_field,
383 &upb_0test__ModelWithExtensions_msg_init));
384
385 const int decode_options =
386 upb_DecodeOptions_MaxDepth(0); // UPB_DECODE_ALIAS disabled.
387 upb_test_ModelWithExtensions* promoted;
388 upb_DecodeStatus promote_result =
389 upb_Message_PromoteMessage(msg, mini_table, submsg_field, decode_options,
390 arena.ptr(), (upb_Message**)&promoted);
391 EXPECT_EQ(promote_result, kUpb_DecodeStatus_Ok);
392 EXPECT_NE(nullptr, promoted);
393 EXPECT_EQ(UPB_UPCAST(promoted), upb_Message_GetMessage(msg, submsg_field));
394 EXPECT_EQ(upb_test_ModelWithExtensions_random_int32(promoted), 12);
395 }
396
397 // Tests a second parse that reuses an empty/unlinked message while the message
398 // is still unlinked.
TEST(GeneratedCode,ReparseUnlinked)399 TEST(GeneratedCode, ReparseUnlinked) {
400 upb::Arena arena;
401 upb_test_ModelWithSubMessages* input_msg =
402 upb_test_ModelWithSubMessages_new(arena.ptr());
403 upb_test_ModelWithExtensions* sub_message =
404 upb_test_ModelWithExtensions_new(arena.ptr());
405 upb_test_ModelWithSubMessages_set_id(input_msg, 11);
406 upb_test_ModelWithExtensions_add_repeated_int32(sub_message, 12, arena.ptr());
407 upb_test_ModelWithSubMessages_set_optional_child(input_msg, sub_message);
408 size_t serialized_size;
409 char* serialized = upb_test_ModelWithSubMessages_serialize(
410 input_msg, arena.ptr(), &serialized_size);
411
412 upb_MiniTable* mini_table = CreateMiniTableWithEmptySubTables(arena.ptr());
413
414 // Parse twice without linking the MiniTable.
415 upb_Message* msg = _upb_Message_New(mini_table, arena.ptr());
416 upb_DecodeStatus decode_status =
417 upb_Decode(serialized, serialized_size, msg, mini_table, nullptr,
418 kUpb_DecodeOption_ExperimentalAllowUnlinked, arena.ptr());
419 EXPECT_EQ(decode_status, kUpb_DecodeStatus_Ok);
420
421 decode_status =
422 upb_Decode(serialized, serialized_size, msg, mini_table, nullptr,
423 kUpb_DecodeOption_ExperimentalAllowUnlinked, arena.ptr());
424 EXPECT_EQ(decode_status, kUpb_DecodeStatus_Ok);
425
426 // Update mini table and promote unknown to a message.
427 const upb_MiniTableField* submsg_field =
428 upb_MiniTable_FindFieldByNumber(mini_table, 5);
429 EXPECT_TRUE(
430 upb_MiniTable_SetSubMessage(mini_table, (upb_MiniTableField*)submsg_field,
431 &upb_0test__ModelWithExtensions_msg_init));
432
433 const int decode_options =
434 upb_DecodeOptions_MaxDepth(0); // UPB_DECODE_ALIAS disabled.
435 upb_test_ModelWithExtensions* promoted;
436 upb_DecodeStatus promote_result =
437 upb_Message_PromoteMessage(msg, mini_table, submsg_field, decode_options,
438 arena.ptr(), (upb_Message**)&promoted);
439 EXPECT_EQ(promote_result, kUpb_DecodeStatus_Ok);
440 EXPECT_NE(nullptr, promoted);
441 EXPECT_EQ(UPB_UPCAST(promoted), upb_Message_GetMessage(msg, submsg_field));
442
443 // The repeated field should have two entries for the two parses.
444 size_t repeated_size;
445 const int32_t* entries =
446 upb_test_ModelWithExtensions_repeated_int32(promoted, &repeated_size);
447 EXPECT_EQ(repeated_size, 2);
448 EXPECT_EQ(entries[0], 12);
449 EXPECT_EQ(entries[1], 12);
450 }
451
452 // Tests a second parse that promotes a message within the parser because we are
453 // merging into an empty/unlinked message after the message has been linked.
TEST(GeneratedCode,PromoteInParser)454 TEST(GeneratedCode, PromoteInParser) {
455 upb::Arena arena;
456 upb_test_ModelWithSubMessages* input_msg =
457 upb_test_ModelWithSubMessages_new(arena.ptr());
458 upb_test_ModelWithExtensions* sub_message =
459 upb_test_ModelWithExtensions_new(arena.ptr());
460 upb_test_ModelWithSubMessages_set_id(input_msg, 11);
461 upb_test_ModelWithExtensions_add_repeated_int32(sub_message, 12, arena.ptr());
462 upb_test_ModelWithSubMessages_set_optional_child(input_msg, sub_message);
463 size_t serialized_size;
464 char* serialized = upb_test_ModelWithSubMessages_serialize(
465 input_msg, arena.ptr(), &serialized_size);
466
467 upb_MiniTable* mini_table = CreateMiniTableWithEmptySubTables(arena.ptr());
468
469 // Parse once without linking the MiniTable.
470 upb_Message* msg = _upb_Message_New(mini_table, arena.ptr());
471 upb_DecodeStatus decode_status =
472 upb_Decode(serialized, serialized_size, msg, mini_table, nullptr,
473 kUpb_DecodeOption_ExperimentalAllowUnlinked, arena.ptr());
474 EXPECT_EQ(decode_status, kUpb_DecodeStatus_Ok);
475
476 // Link the MiniTable.
477 const upb_MiniTableField* submsg_field =
478 upb_MiniTable_FindFieldByNumber(mini_table, 5);
479 EXPECT_TRUE(
480 upb_MiniTable_SetSubMessage(mini_table, (upb_MiniTableField*)submsg_field,
481 &upb_0test__ModelWithExtensions_msg_init));
482
483 // Parse again. This will promote the message. An explicit promote will not
484 // be required.
485 decode_status =
486 upb_Decode(serialized, serialized_size, msg, mini_table, nullptr,
487 kUpb_DecodeOption_ExperimentalAllowUnlinked, arena.ptr());
488 EXPECT_EQ(decode_status, kUpb_DecodeStatus_Ok);
489 upb_test_ModelWithExtensions* promoted =
490 (upb_test_ModelWithExtensions*)upb_Message_GetMessage(msg, submsg_field);
491
492 EXPECT_NE(nullptr, promoted);
493 EXPECT_EQ(UPB_UPCAST(promoted), upb_Message_GetMessage(msg, submsg_field));
494
495 // The repeated field should have two entries for the two parses.
496 size_t repeated_size;
497 const int32_t* entries =
498 upb_test_ModelWithExtensions_repeated_int32(promoted, &repeated_size);
499 EXPECT_EQ(repeated_size, 2);
500 EXPECT_EQ(entries[0], 12);
501 EXPECT_EQ(entries[1], 12);
502 }
503
TEST(GeneratedCode,PromoteUnknownRepeatedMessage)504 TEST(GeneratedCode, PromoteUnknownRepeatedMessage) {
505 upb::Arena arena;
506 upb_test_ModelWithSubMessages* input_msg =
507 upb_test_ModelWithSubMessages_new(arena.ptr());
508 upb_test_ModelWithSubMessages_set_id(input_msg, 123);
509
510 // Add 2 repeated messages to input_msg.
511 upb_test_ModelWithExtensions* item =
512 upb_test_ModelWithSubMessages_add_items(input_msg, arena.ptr());
513 upb_test_ModelWithExtensions_set_random_int32(item, 5);
514 item = upb_test_ModelWithSubMessages_add_items(input_msg, arena.ptr());
515 upb_test_ModelWithExtensions_set_random_int32(item, 6);
516
517 size_t serialized_size;
518 char* serialized = upb_test_ModelWithSubMessages_serialize(
519 input_msg, arena.ptr(), &serialized_size);
520
521 upb_MiniTable* mini_table = CreateMiniTableWithEmptySubTables(arena.ptr());
522 upb_DecodeStatus decode_status;
523
524 // If we parse without allowing unlinked objects, the parse will fail.
525 // TODO: re-enable this test once the old method of tree shaking is
526 // removed
527 // upb_Message* fail_msg = _upb_Message_New(mini_table, arena.ptr());
528 // decode_status =
529 // upb_Decode(serialized, serialized_size, fail_msg, mini_table, nullptr,
530 // 0,
531 // arena.ptr());
532 // EXPECT_EQ(decode_status, kUpb_DecodeStatus_UnlinkedSubMessage);
533
534 // if we parse while allowing unlinked objects, the parse will succeed.
535 upb_Message* msg = _upb_Message_New(mini_table, arena.ptr());
536 decode_status =
537 upb_Decode(serialized, serialized_size, msg, mini_table, nullptr,
538 kUpb_DecodeOption_ExperimentalAllowUnlinked, arena.ptr());
539
540 CheckReserialize(msg, mini_table, arena.ptr(), serialized, serialized_size);
541
542 // Int32 field is present, as normal.
543 EXPECT_EQ(decode_status, kUpb_DecodeStatus_Ok);
544 int32_t val = upb_Message_GetInt32(
545 msg, upb_MiniTable_FindFieldByNumber(mini_table, 4), 0);
546 EXPECT_EQ(val, 123);
547
548 const upb_MiniTableField* repeated_field =
549 upb_MiniTable_FindFieldByNumber(mini_table, 6);
550
551 upb_Array* array = upb_Message_GetMutableArray(msg, repeated_field);
552
553 // Array length is 2 even though the messages are empty.
554 EXPECT_EQ(2, upb_Array_Size(array));
555
556 // Update mini table and promote unknown to a message.
557 EXPECT_TRUE(upb_MiniTable_SetSubMessage(
558 mini_table, (upb_MiniTableField*)repeated_field,
559 &upb_0test__ModelWithExtensions_msg_init));
560 const int decode_options =
561 upb_DecodeOptions_MaxDepth(0); // UPB_DECODE_ALIAS disabled.
562 upb_DecodeStatus promote_result =
563 upb_Array_PromoteMessages(array, &upb_0test__ModelWithExtensions_msg_init,
564 decode_options, arena.ptr());
565 EXPECT_EQ(promote_result, kUpb_DecodeStatus_Ok);
566 const upb_Message* promoted_message = upb_Array_Get(array, 0).msg_val;
567 EXPECT_EQ(upb_test_ModelWithExtensions_random_int32(
568 (upb_test_ModelWithExtensions*)promoted_message),
569 5);
570 promoted_message = upb_Array_Get(array, 1).msg_val;
571 EXPECT_EQ(upb_test_ModelWithExtensions_random_int32(
572 (upb_test_ModelWithExtensions*)promoted_message),
573 6);
574 }
575
TEST(GeneratedCode,PromoteUnknownToMap)576 TEST(GeneratedCode, PromoteUnknownToMap) {
577 upb::Arena arena;
578 upb_test_ModelWithMaps* input_msg = upb_test_ModelWithMaps_new(arena.ptr());
579 upb_test_ModelWithMaps_set_id(input_msg, 123);
580
581 upb_test_ModelWithExtensions* submsg1 =
582 upb_test_ModelWithExtensions_new(arena.ptr());
583 upb_test_ModelWithExtensions_set_random_int32(submsg1, 123);
584 upb_test_ModelWithExtensions* submsg2 =
585 upb_test_ModelWithExtensions_new(arena.ptr());
586 upb_test_ModelWithExtensions_set_random_int32(submsg2, 456);
587
588 // Add 2 map entries.
589 upb_test_ModelWithMaps_map_im_set(input_msg, 111, submsg1, arena.ptr());
590 upb_test_ModelWithMaps_map_im_set(input_msg, 222, submsg2, arena.ptr());
591
592 size_t serialized_size;
593 char* serialized = upb_test_ModelWithMaps_serialize_ex(
594 input_msg, kUpb_EncodeOption_Deterministic, arena.ptr(),
595 &serialized_size);
596
597 upb_MiniTable* mini_table =
598 CreateMiniTableWithEmptySubTablesForMaps(arena.ptr());
599
600 // If we parse without allowing unlinked objects, the parse will fail.
601 upb_Message* fail_msg1 = _upb_Message_New(mini_table, arena.ptr());
602 upb_DecodeStatus decode_status =
603 upb_Decode(serialized, serialized_size, fail_msg1, mini_table, nullptr, 0,
604 arena.ptr());
605 EXPECT_EQ(decode_status, kUpb_DecodeStatus_UnlinkedSubMessage);
606
607 // if we parse while allowing unlinked objects, the parse will succeed.
608 upb_Message* msg = _upb_Message_New(mini_table, arena.ptr());
609 decode_status =
610 upb_Decode(serialized, serialized_size, msg, mini_table, nullptr,
611 kUpb_DecodeOption_ExperimentalAllowUnlinked, arena.ptr());
612 EXPECT_EQ(decode_status, kUpb_DecodeStatus_Ok);
613
614 CheckReserialize(msg, mini_table, arena.ptr(), serialized, serialized_size);
615
616 upb_MiniTableField* map_field = const_cast<upb_MiniTableField*>(
617 upb_MiniTable_FindFieldByNumber(mini_table, 5));
618
619 upb_Map* map = upb_Message_GetMutableMap(msg, map_field);
620
621 // Map size is 2 even though messages are unlinked.
622 EXPECT_EQ(2, upb_Map_Size(map));
623
624 // Update mini table and promote unknown to a message.
625 upb_MiniTable* entry = const_cast<upb_MiniTable*>(
626 upb_MiniTable_GetSubMessageTable(mini_table, map_field));
627 upb_MiniTableField* entry_value = const_cast<upb_MiniTableField*>(
628 upb_MiniTable_FindFieldByNumber(entry, 2));
629 upb_MiniTable_SetSubMessage(entry, entry_value,
630 &upb_0test__ModelWithExtensions_msg_init);
631 upb_DecodeStatus promote_result = upb_Map_PromoteMessages(
632 map, &upb_0test__ModelWithExtensions_msg_init, 0, arena.ptr());
633 EXPECT_EQ(promote_result, kUpb_DecodeStatus_Ok);
634
635 upb_MessageValue key;
636 upb_MessageValue val;
637 key.int32_val = 111;
638 EXPECT_TRUE(upb_Map_Get(map, key, &val));
639 EXPECT_EQ(123, upb_test_ModelWithExtensions_random_int32(
640 static_cast<const upb_test_ModelWithExtensions*>(
641 (void*)(val.msg_val))));
642
643 key.int32_val = 222;
644 EXPECT_TRUE(upb_Map_Get(map, key, &val));
645 EXPECT_EQ(456, upb_test_ModelWithExtensions_random_int32(
646 static_cast<const upb_test_ModelWithExtensions*>(
647 (void*)(val.msg_val))));
648 }
649
650 } // namespace
651
652 // OLD tests, to be removed!
653
654 namespace {
655
656 // Create a minitable to mimic ModelWithSubMessages with unlinked subs
657 // to lazily promote unknowns after parsing.
CreateMiniTableWithEmptySubTablesOld(upb_Arena * arena)658 upb_MiniTable* CreateMiniTableWithEmptySubTablesOld(upb_Arena* arena) {
659 upb::MtDataEncoder e;
660 e.StartMessage(0);
661 e.PutField(kUpb_FieldType_Int32, 4, 0);
662 e.PutField(kUpb_FieldType_Message, 5, 0);
663 e.PutField(kUpb_FieldType_Message, 6, kUpb_FieldModifier_IsRepeated);
664
665 upb_Status status;
666 upb_Status_Clear(&status);
667 upb_MiniTable* table =
668 upb_MiniTable_Build(e.data().data(), e.data().size(), arena, &status);
669 EXPECT_EQ(status.ok, true);
670 return table;
671 }
672
673 // Create a minitable to mimic ModelWithMaps with unlinked subs
674 // to lazily promote unknowns after parsing.
CreateMiniTableWithEmptySubTablesForMapsOld(upb_Arena * arena)675 upb_MiniTable* CreateMiniTableWithEmptySubTablesForMapsOld(upb_Arena* arena) {
676 upb::MtDataEncoder e;
677 e.StartMessage(0);
678 e.PutField(kUpb_FieldType_Int32, 1, 0);
679 e.PutField(kUpb_FieldType_Message, 3, kUpb_FieldModifier_IsRepeated);
680 e.PutField(kUpb_FieldType_Message, 4, kUpb_FieldModifier_IsRepeated);
681
682 upb_Status status;
683 upb_Status_Clear(&status);
684 upb_MiniTable* table =
685 upb_MiniTable_Build(e.data().data(), e.data().size(), arena, &status);
686 EXPECT_EQ(status.ok, true);
687 return table;
688 }
689
CreateMapEntryMiniTableOld(upb_Arena * arena)690 upb_MiniTable* CreateMapEntryMiniTableOld(upb_Arena* arena) {
691 upb::MtDataEncoder e;
692 e.EncodeMap(kUpb_FieldType_String, kUpb_FieldType_String, 0, 0);
693 upb_Status status;
694 upb_Status_Clear(&status);
695 upb_MiniTable* table =
696 upb_MiniTable_Build(e.data().data(), e.data().size(), arena, &status);
697 EXPECT_EQ(status.ok, true);
698 return table;
699 }
700
TEST(GeneratedCode,PromoteUnknownMessageOld)701 TEST(GeneratedCode, PromoteUnknownMessageOld) {
702 upb_Arena* arena = upb_Arena_New();
703 upb_test_ModelWithSubMessages* input_msg =
704 upb_test_ModelWithSubMessages_new(arena);
705 upb_test_ModelWithExtensions* sub_message =
706 upb_test_ModelWithExtensions_new(arena);
707 upb_test_ModelWithSubMessages_set_id(input_msg, 11);
708 upb_test_ModelWithExtensions_set_random_int32(sub_message, 12);
709 upb_test_ModelWithSubMessages_set_optional_child(input_msg, sub_message);
710 size_t serialized_size;
711 char* serialized = upb_test_ModelWithSubMessages_serialize(input_msg, arena,
712 &serialized_size);
713
714 upb_MiniTable* mini_table = CreateMiniTableWithEmptySubTablesOld(arena);
715 upb_Message* msg = _upb_Message_New(mini_table, arena);
716 upb_DecodeStatus decode_status = upb_Decode(serialized, serialized_size, msg,
717 mini_table, nullptr, 0, arena);
718 EXPECT_EQ(decode_status, kUpb_DecodeStatus_Ok);
719 int32_t val = upb_Message_GetInt32(
720 msg, upb_MiniTable_FindFieldByNumber(mini_table, 4), 0);
721 EXPECT_EQ(val, 11);
722 upb_FindUnknownRet unknown = upb_Message_FindUnknown(msg, 5, 0);
723 EXPECT_EQ(unknown.status, kUpb_FindUnknown_Ok);
724 // Update mini table and promote unknown to a message.
725 EXPECT_TRUE(upb_MiniTable_SetSubMessage(
726 mini_table,
727 (upb_MiniTableField*)upb_MiniTable_GetFieldByIndex(mini_table, 1),
728 &upb_0test__ModelWithExtensions_msg_init));
729 const int decode_options =
730 upb_DecodeOptions_MaxDepth(0); // UPB_DECODE_ALIAS disabled.
731 upb_UnknownToMessageRet promote_result =
732 upb_MiniTable_PromoteUnknownToMessage(
733 msg, mini_table, upb_MiniTable_GetFieldByIndex(mini_table, 1),
734 &upb_0test__ModelWithExtensions_msg_init, decode_options, arena);
735 EXPECT_EQ(promote_result.status, kUpb_UnknownToMessage_Ok);
736 const upb_Message* promoted_message =
737 upb_Message_GetMessage(msg, upb_MiniTable_GetFieldByIndex(mini_table, 1));
738 EXPECT_EQ(upb_test_ModelWithExtensions_random_int32(
739 (upb_test_ModelWithExtensions*)promoted_message),
740 12);
741 upb_Arena_Free(arena);
742 }
743
TEST(GeneratedCode,PromoteUnknownRepeatedMessageOld)744 TEST(GeneratedCode, PromoteUnknownRepeatedMessageOld) {
745 upb_Arena* arena = upb_Arena_New();
746 upb_test_ModelWithSubMessages* input_msg =
747 upb_test_ModelWithSubMessages_new(arena);
748 upb_test_ModelWithSubMessages_set_id(input_msg, 123);
749
750 // Add 2 repeated messages to input_msg.
751 upb_test_ModelWithExtensions* item =
752 upb_test_ModelWithSubMessages_add_items(input_msg, arena);
753 upb_test_ModelWithExtensions_set_random_int32(item, 5);
754 item = upb_test_ModelWithSubMessages_add_items(input_msg, arena);
755 upb_test_ModelWithExtensions_set_random_int32(item, 6);
756
757 size_t serialized_size;
758 char* serialized = upb_test_ModelWithSubMessages_serialize(input_msg, arena,
759 &serialized_size);
760
761 upb_MiniTable* mini_table = CreateMiniTableWithEmptySubTablesOld(arena);
762 upb_Message* msg = _upb_Message_New(mini_table, arena);
763 upb_DecodeStatus decode_status = upb_Decode(serialized, serialized_size, msg,
764 mini_table, nullptr, 0, arena);
765 EXPECT_EQ(decode_status, kUpb_DecodeStatus_Ok);
766 int32_t val = upb_Message_GetInt32(
767 msg, upb_MiniTable_FindFieldByNumber(mini_table, 4), 0);
768 EXPECT_EQ(val, 123);
769
770 // Check that we have repeated field data in an unknown.
771 upb_FindUnknownRet unknown = upb_Message_FindUnknown(msg, 6, 0);
772 EXPECT_EQ(unknown.status, kUpb_FindUnknown_Ok);
773
774 // Update mini table and promote unknown to a message.
775 EXPECT_TRUE(upb_MiniTable_SetSubMessage(
776 mini_table,
777 (upb_MiniTableField*)upb_MiniTable_GetFieldByIndex(mini_table, 2),
778 &upb_0test__ModelWithExtensions_msg_init));
779 const int decode_options =
780 upb_DecodeOptions_MaxDepth(0); // UPB_DECODE_ALIAS disabled.
781 upb_UnknownToMessage_Status promote_result =
782 upb_MiniTable_PromoteUnknownToMessageArray(
783 msg, upb_MiniTable_GetFieldByIndex(mini_table, 2),
784 &upb_0test__ModelWithExtensions_msg_init, decode_options, arena);
785 EXPECT_EQ(promote_result, kUpb_UnknownToMessage_Ok);
786
787 upb_Array* array = upb_Message_GetMutableArray(
788 msg, upb_MiniTable_GetFieldByIndex(mini_table, 2));
789 const upb_Message* promoted_message = upb_Array_Get(array, 0).msg_val;
790 EXPECT_EQ(upb_test_ModelWithExtensions_random_int32(
791 (upb_test_ModelWithExtensions*)promoted_message),
792 5);
793 promoted_message = upb_Array_Get(array, 1).msg_val;
794 EXPECT_EQ(upb_test_ModelWithExtensions_random_int32(
795 (upb_test_ModelWithExtensions*)promoted_message),
796 6);
797 upb_Arena_Free(arena);
798 }
799
TEST(GeneratedCode,PromoteUnknownToMapOld)800 TEST(GeneratedCode, PromoteUnknownToMapOld) {
801 upb_Arena* arena = upb_Arena_New();
802 upb_test_ModelWithMaps* input_msg = upb_test_ModelWithMaps_new(arena);
803 upb_test_ModelWithMaps_set_id(input_msg, 123);
804
805 // Add 2 map entries.
806 upb_test_ModelWithMaps_map_ss_set(input_msg,
807 upb_StringView_FromString("key1"),
808 upb_StringView_FromString("value1"), arena);
809 upb_test_ModelWithMaps_map_ss_set(input_msg,
810 upb_StringView_FromString("key2"),
811 upb_StringView_FromString("value2"), arena);
812
813 size_t serialized_size;
814 char* serialized =
815 upb_test_ModelWithMaps_serialize(input_msg, arena, &serialized_size);
816
817 upb_MiniTable* mini_table =
818 CreateMiniTableWithEmptySubTablesForMapsOld(arena);
819 upb_MiniTable* map_entry_mini_table = CreateMapEntryMiniTableOld(arena);
820 upb_Message* msg = _upb_Message_New(mini_table, arena);
821 const int decode_options = upb_DecodeOptions_MaxDepth(0);
822 upb_DecodeStatus decode_status =
823 upb_Decode(serialized, serialized_size, msg, mini_table, nullptr,
824 decode_options, arena);
825 EXPECT_EQ(decode_status, kUpb_DecodeStatus_Ok);
826 int32_t val = upb_Message_GetInt32(
827 msg, upb_MiniTable_FindFieldByNumber(mini_table, 1), 0);
828 EXPECT_EQ(val, 123);
829
830 // Check that we have map data in an unknown.
831 upb_FindUnknownRet unknown = upb_Message_FindUnknown(msg, 3, 0);
832 EXPECT_EQ(unknown.status, kUpb_FindUnknown_Ok);
833
834 // Update mini table and promote unknown to a message.
835 EXPECT_TRUE(upb_MiniTable_SetSubMessage(
836 mini_table,
837 (upb_MiniTableField*)upb_MiniTable_GetFieldByIndex(mini_table, 1),
838 map_entry_mini_table));
839 upb_UnknownToMessage_Status promote_result =
840 upb_MiniTable_PromoteUnknownToMap(
841 msg, mini_table, upb_MiniTable_GetFieldByIndex(mini_table, 1),
842 decode_options, arena);
843 EXPECT_EQ(promote_result, kUpb_UnknownToMessage_Ok);
844
845 upb_Map* map = upb_Message_GetOrCreateMutableMap(
846 msg, map_entry_mini_table, upb_MiniTable_GetFieldByIndex(mini_table, 1),
847 arena);
848 EXPECT_NE(map, nullptr);
849 // Lookup in map.
850 upb_MessageValue key;
851 key.str_val = upb_StringView_FromString("key2");
852 upb_MessageValue value;
853 EXPECT_TRUE(upb_Map_Get(map, key, &value));
854 EXPECT_EQ(0, strncmp(value.str_val.data, "value2", 5));
855 upb_Arena_Free(arena);
856 }
857
858 } // namespace
859