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 generated code, with a special focus on features that are not used in
9 * descriptor.proto or conformance.proto (since these get some testing from
10 * upb/def.c and tests/conformance_upb.c, respectively).
11 */
12
13 #include <cstddef>
14 #include <cstdint>
15
16 #include <gtest/gtest.h>
17 #include "google/protobuf/test_messages_proto2.upb.h"
18 #include "google/protobuf/test_messages_proto3.upb.h"
19 #include "upb/base/status.h"
20 #include "upb/base/string_view.h"
21 #include "upb/mem/arena.hpp"
22 #include "upb/message/array.h"
23 #include "upb/message/map.h"
24 #include "upb/test/test.upb.h"
25
26 // Must be last.
27 #include "upb/port/def.inc"
28
29 #if !defined(MIN)
30 #define MIN(x, y) ((x) < (y) ? (x) : (y))
31 #endif
32
33 const char test_str[] = "abcdefg";
34 const char test_str2[] = "12345678910";
35 const char test_str3[] = "rstlnezxcvbnm";
36 const char test_str4[] = "just another test string";
37
38 const upb_StringView test_str_view = {test_str, sizeof(test_str) - 1};
39 const upb_StringView test_str_view2 = {test_str2, sizeof(test_str2) - 1};
40 const upb_StringView test_str_view3 = {test_str3, sizeof(test_str3) - 1};
41 const upb_StringView test_str_view4 = {test_str4, sizeof(test_str4) - 1};
42
43 const int32_t test_int32 = 10;
44 const int32_t test_int32_2 = -20;
45 const int32_t test_int32_3 = 30;
46 const int32_t test_int32_4 = -40;
47
TEST(GeneratedCode,ScalarsProto3)48 TEST(GeneratedCode, ScalarsProto3) {
49 upb_Arena* arena = upb_Arena_New();
50 protobuf_test_messages_proto3_TestAllTypesProto3* msg =
51 protobuf_test_messages_proto3_TestAllTypesProto3_new(arena);
52 protobuf_test_messages_proto3_TestAllTypesProto3* msg2;
53 upb_StringView serialized;
54 upb_StringView val;
55
56 // Test serialization.
57 protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_int32(msg, 10);
58 protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_int64(msg, 20);
59 protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_uint32(msg, 30);
60 protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_uint64(msg, 40);
61 protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_float(msg,
62 50.5);
63 protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_double(msg,
64 60.6);
65 protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_bool(msg, true);
66 protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_string(
67 msg, test_str_view);
68
69 serialized.data = protobuf_test_messages_proto3_TestAllTypesProto3_serialize(
70 msg, arena, &serialized.size);
71
72 msg2 = protobuf_test_messages_proto3_TestAllTypesProto3_parse(
73 serialized.data, serialized.size, arena);
74
75 EXPECT_EQ(10, protobuf_test_messages_proto3_TestAllTypesProto3_optional_int32(
76 msg2));
77 EXPECT_EQ(20, protobuf_test_messages_proto3_TestAllTypesProto3_optional_int64(
78 msg2));
79 EXPECT_EQ(
80 30,
81 protobuf_test_messages_proto3_TestAllTypesProto3_optional_uint32(msg2));
82 EXPECT_EQ(
83 40,
84 protobuf_test_messages_proto3_TestAllTypesProto3_optional_uint64(msg2));
85 EXPECT_EQ(
86 50.5,
87 protobuf_test_messages_proto3_TestAllTypesProto3_optional_float(msg2));
88 EXPECT_EQ(
89 60.6,
90 protobuf_test_messages_proto3_TestAllTypesProto3_optional_double(msg2));
91 EXPECT_EQ(
92 true,
93 protobuf_test_messages_proto3_TestAllTypesProto3_optional_bool(msg2));
94 val = protobuf_test_messages_proto3_TestAllTypesProto3_optional_string(msg2);
95 EXPECT_TRUE(upb_StringView_IsEqual(val, test_str_view));
96
97 // Test clear.
98 protobuf_test_messages_proto3_TestAllTypesProto3_clear_optional_int32(msg);
99 EXPECT_EQ(
100 0, protobuf_test_messages_proto3_TestAllTypesProto3_optional_int32(msg));
101 protobuf_test_messages_proto3_TestAllTypesProto3_clear_optional_int64(msg);
102 EXPECT_EQ(
103 0, protobuf_test_messages_proto3_TestAllTypesProto3_optional_int64(msg));
104 protobuf_test_messages_proto3_TestAllTypesProto3_clear_optional_uint32(msg);
105 EXPECT_EQ(
106 0, protobuf_test_messages_proto3_TestAllTypesProto3_optional_uint32(msg));
107 protobuf_test_messages_proto3_TestAllTypesProto3_clear_optional_uint64(msg);
108 EXPECT_EQ(
109 0, protobuf_test_messages_proto3_TestAllTypesProto3_optional_uint64(msg));
110 protobuf_test_messages_proto3_TestAllTypesProto3_clear_optional_float(msg);
111 EXPECT_EQ(
112 0.0f,
113 protobuf_test_messages_proto3_TestAllTypesProto3_optional_float(msg));
114 protobuf_test_messages_proto3_TestAllTypesProto3_clear_optional_double(msg);
115 EXPECT_EQ(
116 0.0,
117 protobuf_test_messages_proto3_TestAllTypesProto3_optional_double(msg));
118 protobuf_test_messages_proto3_TestAllTypesProto3_clear_optional_bool(msg);
119 EXPECT_EQ(
120 false,
121 protobuf_test_messages_proto3_TestAllTypesProto3_optional_bool(msg));
122 protobuf_test_messages_proto3_TestAllTypesProto3_clear_optional_string(msg);
123 EXPECT_EQ(
124 0, protobuf_test_messages_proto3_TestAllTypesProto3_optional_string(msg)
125 .size);
126 upb_Arena_Free(arena);
127 }
128
TEST(GeneratedCode,ScalarsProto2)129 TEST(GeneratedCode, ScalarsProto2) {
130 upb_Arena* arena = upb_Arena_New();
131 protobuf_test_messages_proto2_TestAllTypesProto2* msg =
132 protobuf_test_messages_proto2_TestAllTypesProto2_new(arena);
133 protobuf_test_messages_proto2_TestAllTypesProto2* msg2;
134 upb_StringView serialized;
135
136 // Test hazzer and serialization.
137 EXPECT_EQ(
138 false,
139 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_int32(msg));
140 protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_int32(msg, 10);
141 EXPECT_EQ(
142 true,
143 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_int32(msg));
144 EXPECT_EQ(
145 false,
146 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_int64(msg));
147 protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_int64(msg, 20);
148 EXPECT_EQ(
149 true,
150 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_int64(msg));
151 EXPECT_EQ(
152 false,
153 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_uint32(
154 msg));
155 protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_uint32(msg, 30);
156 EXPECT_EQ(
157 true,
158 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_uint32(
159 msg));
160 EXPECT_EQ(
161 false,
162 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_uint64(
163 msg));
164 protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_uint64(msg, 40);
165 EXPECT_EQ(
166 true,
167 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_uint64(
168 msg));
169 EXPECT_EQ(
170 false,
171 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_sint32(
172 msg));
173 protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_sint32(msg, 50);
174 EXPECT_EQ(
175 true,
176 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_sint32(
177 msg));
178 EXPECT_EQ(
179 false,
180 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_sint64(
181 msg));
182 protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_sint64(msg, 60);
183 EXPECT_EQ(
184 true,
185 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_sint64(
186 msg));
187 EXPECT_EQ(
188 false,
189 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_fixed32(
190 msg));
191 protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_fixed32(msg,
192 70);
193 EXPECT_EQ(
194 true,
195 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_fixed32(
196 msg));
197 EXPECT_EQ(
198 false,
199 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_fixed64(
200 msg));
201 protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_fixed64(msg,
202 80);
203 EXPECT_EQ(
204 true,
205 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_fixed64(
206 msg));
207 EXPECT_EQ(
208 false,
209 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_sfixed32(
210 msg));
211 protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_sfixed32(msg,
212 90);
213 EXPECT_EQ(
214 true,
215 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_sfixed32(
216 msg));
217 EXPECT_EQ(
218 false,
219 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_sfixed64(
220 msg));
221 protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_sfixed64(msg,
222 100);
223 EXPECT_EQ(
224 true,
225 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_sfixed64(
226 msg));
227 EXPECT_EQ(
228 false,
229 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_float(msg));
230 protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_float(msg,
231 50.5);
232 EXPECT_EQ(
233 true,
234 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_float(msg));
235 EXPECT_EQ(
236 false,
237 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_double(
238 msg));
239 protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_double(msg,
240 60.6);
241 EXPECT_EQ(
242 true,
243 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_double(
244 msg));
245 EXPECT_EQ(
246 false,
247 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_bool(msg));
248 protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_bool(msg, true);
249 EXPECT_EQ(
250 true,
251 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_bool(msg));
252
253 serialized.data = protobuf_test_messages_proto2_TestAllTypesProto2_serialize(
254 msg, arena, &serialized.size);
255
256 msg2 = protobuf_test_messages_proto2_TestAllTypesProto2_parse(
257 serialized.data, serialized.size, arena);
258
259 EXPECT_EQ(10, protobuf_test_messages_proto2_TestAllTypesProto2_optional_int32(
260 msg2));
261 EXPECT_EQ(20, protobuf_test_messages_proto2_TestAllTypesProto2_optional_int64(
262 msg2));
263 EXPECT_EQ(
264 30,
265 protobuf_test_messages_proto2_TestAllTypesProto2_optional_uint32(msg2));
266 EXPECT_EQ(
267 40,
268 protobuf_test_messages_proto2_TestAllTypesProto2_optional_uint64(msg2));
269 EXPECT_EQ(
270 50,
271 protobuf_test_messages_proto2_TestAllTypesProto2_optional_sint32(msg2));
272 EXPECT_EQ(
273 60,
274 protobuf_test_messages_proto2_TestAllTypesProto2_optional_sint64(msg2));
275 EXPECT_EQ(
276 70,
277 protobuf_test_messages_proto2_TestAllTypesProto2_optional_fixed32(msg2));
278 EXPECT_EQ(
279 80,
280 protobuf_test_messages_proto2_TestAllTypesProto2_optional_fixed64(msg2));
281 EXPECT_EQ(
282 90,
283 protobuf_test_messages_proto2_TestAllTypesProto2_optional_sfixed32(msg2));
284 EXPECT_EQ(
285 100,
286 protobuf_test_messages_proto2_TestAllTypesProto2_optional_sfixed64(msg2));
287 EXPECT_EQ(
288 50.5,
289 protobuf_test_messages_proto2_TestAllTypesProto2_optional_float(msg2));
290 EXPECT_EQ(
291 60.6,
292 protobuf_test_messages_proto2_TestAllTypesProto2_optional_double(msg2));
293 EXPECT_EQ(
294 true,
295 protobuf_test_messages_proto2_TestAllTypesProto2_optional_bool(msg2));
296
297 // Test clear.
298 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_int32(msg);
299 EXPECT_EQ(
300 0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_int32(msg));
301 EXPECT_EQ(
302 false,
303 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_int32(msg));
304
305 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_int64(msg);
306 EXPECT_EQ(
307 0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_int64(msg));
308 EXPECT_EQ(
309 false,
310 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_int64(msg));
311 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_uint32(msg);
312 EXPECT_EQ(
313 0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_uint32(msg));
314 EXPECT_EQ(
315 false,
316 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_uint32(
317 msg));
318 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_uint64(msg);
319 EXPECT_EQ(
320 0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_uint64(msg));
321 EXPECT_EQ(
322 false,
323 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_uint64(
324 msg));
325 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_float(msg);
326 EXPECT_EQ(
327 0.0f,
328 protobuf_test_messages_proto2_TestAllTypesProto2_optional_float(msg));
329 EXPECT_EQ(
330 false,
331 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_float(msg));
332 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_double(msg);
333 EXPECT_EQ(
334 0.0,
335 protobuf_test_messages_proto2_TestAllTypesProto2_optional_double(msg));
336 EXPECT_EQ(
337 false,
338 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_double(
339 msg));
340 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_bool(msg);
341 EXPECT_EQ(
342 false,
343 protobuf_test_messages_proto2_TestAllTypesProto2_optional_bool(msg));
344 EXPECT_EQ(
345 false,
346 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_bool(msg));
347
348 upb_Arena_Free(arena);
349 }
350
TEST(GeneratedCode,RepeatedClear)351 TEST(GeneratedCode, RepeatedClear) {
352 upb_Arena* arena = upb_Arena_New();
353 protobuf_test_messages_proto2_TestAllTypesProto2* msg =
354 protobuf_test_messages_proto2_TestAllTypesProto2_new(arena);
355 size_t len = 0;
356 protobuf_test_messages_proto2_TestAllTypesProto2_repeated_int32(msg, &len);
357 EXPECT_EQ(0, len);
358 protobuf_test_messages_proto2_TestAllTypesProto2_add_repeated_int32(msg, 2,
359 arena);
360 protobuf_test_messages_proto2_TestAllTypesProto2_add_repeated_int32(msg, 3,
361 arena);
362 protobuf_test_messages_proto2_TestAllTypesProto2_add_repeated_int32(msg, 4,
363 arena);
364 protobuf_test_messages_proto2_TestAllTypesProto2_repeated_int32(msg, &len);
365 EXPECT_EQ(3, len);
366 protobuf_test_messages_proto2_TestAllTypesProto2_clear_repeated_int32(msg);
367 protobuf_test_messages_proto2_TestAllTypesProto2_repeated_int32(msg, &len);
368 EXPECT_EQ(0, len);
369 upb_Arena_Free(arena);
370 }
371
TEST(GeneratedCode,Clear)372 TEST(GeneratedCode, Clear) {
373 upb_Arena* arena = upb_Arena_New();
374 protobuf_test_messages_proto2_TestAllTypesProto2* msg =
375 protobuf_test_messages_proto2_TestAllTypesProto2_new(arena);
376 // Test clear.
377 protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_int32(msg, 1);
378 EXPECT_TRUE(
379 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_int32(msg));
380 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_int32(msg);
381 EXPECT_EQ(
382 0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_int32(msg));
383 EXPECT_FALSE(
384 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_int32(msg));
385 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_int64(msg);
386 EXPECT_EQ(
387 0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_int64(msg));
388 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_uint32(msg);
389 EXPECT_EQ(
390 0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_uint32(msg));
391 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_uint64(msg);
392 EXPECT_EQ(
393 0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_uint64(msg));
394 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_float(msg);
395 EXPECT_EQ(
396 0.0f,
397 protobuf_test_messages_proto2_TestAllTypesProto2_optional_float(msg));
398 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_double(msg);
399 EXPECT_EQ(
400 0.0,
401 protobuf_test_messages_proto2_TestAllTypesProto2_optional_double(msg));
402 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_bool(msg);
403 EXPECT_EQ(
404 false,
405 protobuf_test_messages_proto2_TestAllTypesProto2_optional_bool(msg));
406 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_string(msg);
407 EXPECT_EQ(
408 0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_string(msg)
409 .size);
410 upb_Arena_Free(arena);
411 }
412
TEST(GeneratedCode,Bytes)413 TEST(GeneratedCode, Bytes) {
414 upb_Arena* arena = upb_Arena_New();
415 protobuf_test_messages_proto2_TestAllTypesProto2* msg =
416 protobuf_test_messages_proto2_TestAllTypesProto2_new(arena);
417 protobuf_test_messages_proto2_TestAllTypesProto2* msg2;
418 upb_StringView serialized;
419 const char data[] = "ABCDEF";
420 upb_StringView bytes = upb_StringView_FromString(data);
421 upb_StringView val;
422
423 EXPECT_EQ(
424 false,
425 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_bytes(msg));
426 protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_bytes(msg,
427 bytes);
428 EXPECT_EQ(
429 true,
430 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_bytes(msg));
431
432 EXPECT_EQ(
433 false,
434 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_string(
435 msg));
436 protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_string(
437 msg, test_str_view);
438 EXPECT_EQ(
439 true,
440 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_string(
441 msg));
442
443 serialized.data = protobuf_test_messages_proto2_TestAllTypesProto2_serialize(
444 msg, arena, &serialized.size);
445
446 msg2 = protobuf_test_messages_proto2_TestAllTypesProto2_parse(
447 serialized.data, serialized.size, arena);
448
449 EXPECT_EQ(bytes.size,
450 protobuf_test_messages_proto2_TestAllTypesProto2_optional_bytes(msg)
451 .size);
452 EXPECT_EQ(
453 0, memcmp(bytes.data,
454 protobuf_test_messages_proto2_TestAllTypesProto2_optional_bytes(
455 msg)
456 .data,
457 bytes.size));
458 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_bytes(msg);
459 EXPECT_EQ(
460 false,
461 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_bytes(msg));
462
463 val = protobuf_test_messages_proto2_TestAllTypesProto2_optional_string(msg2);
464 EXPECT_TRUE(upb_StringView_IsEqual(val, test_str_view));
465
466 protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_string(msg);
467 EXPECT_EQ(
468 0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_string(msg)
469 .size);
470 EXPECT_EQ(
471 false,
472 protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_string(
473 msg));
474 upb_Arena_Free(arena);
475 }
476
TEST(GeneratedCode,UTF8)477 TEST(GeneratedCode, UTF8) {
478 const char invalid_utf8[] = "\xff";
479 const upb_StringView invalid_utf8_view =
480 upb_StringView_FromDataAndSize(invalid_utf8, 1);
481 upb_Arena* arena = upb_Arena_New();
482 upb_StringView serialized;
483 protobuf_test_messages_proto3_TestAllTypesProto3* msg =
484 protobuf_test_messages_proto3_TestAllTypesProto3_new(arena);
485 protobuf_test_messages_proto3_TestAllTypesProto3* msg2;
486
487 protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_string(
488 msg, invalid_utf8_view);
489
490 serialized.data = protobuf_test_messages_proto3_TestAllTypesProto3_serialize(
491 msg, arena, &serialized.size);
492
493 msg2 = protobuf_test_messages_proto3_TestAllTypesProto3_parse(
494 serialized.data, serialized.size, arena);
495 EXPECT_EQ(nullptr, msg2);
496
497 upb_Arena_Free(arena);
498 }
499
check_string_map_empty(protobuf_test_messages_proto3_TestAllTypesProto3 * msg)500 static void check_string_map_empty(
501 protobuf_test_messages_proto3_TestAllTypesProto3* msg) {
502 size_t iter = kUpb_Map_Begin;
503
504 EXPECT_EQ(
505 0,
506 protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_size(
507 msg));
508 EXPECT_FALSE(
509 protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_next(
510 msg, &iter));
511 }
512
check_string_map_one_entry(protobuf_test_messages_proto3_TestAllTypesProto3 * msg)513 static void check_string_map_one_entry(
514 protobuf_test_messages_proto3_TestAllTypesProto3* msg) {
515 const protobuf_test_messages_proto3_TestAllTypesProto3_MapStringStringEntry*
516 const_ent;
517 size_t iter;
518 upb_StringView str;
519
520 EXPECT_EQ(
521 1,
522 protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_size(
523 msg));
524 EXPECT_TRUE(
525 protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_get(
526 msg, test_str_view, &str));
527 EXPECT_TRUE(upb_StringView_IsEqual(str, test_str_view2));
528
529 EXPECT_FALSE(
530 protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_get(
531 msg, test_str_view3, &str));
532
533 /* Test that iteration reveals a single k/v pair in the map. */
534 iter = kUpb_Map_Begin;
535 const_ent =
536 protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_next(
537 msg, &iter);
538 ASSERT_NE(nullptr, const_ent);
539 EXPECT_TRUE(upb_StringView_IsEqual(
540 test_str_view,
541 protobuf_test_messages_proto3_TestAllTypesProto3_MapStringStringEntry_key(
542 const_ent)));
543 EXPECT_TRUE(upb_StringView_IsEqual(
544 test_str_view2,
545 protobuf_test_messages_proto3_TestAllTypesProto3_MapStringStringEntry_value(
546 const_ent)));
547
548 const_ent =
549 protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_next(
550 msg, &iter);
551 EXPECT_EQ(nullptr, const_ent);
552 }
553
TEST(GeneratedCode,StringDoubleMap)554 TEST(GeneratedCode, StringDoubleMap) {
555 upb_Arena* arena = upb_Arena_New();
556 upb_StringView serialized;
557 upb_test_MapTest* msg = upb_test_MapTest_new(arena);
558 upb_test_MapTest* msg2;
559 double val;
560
561 upb_test_MapTest_map_string_double_set(msg, test_str_view, 1.5, arena);
562 ASSERT_NE(nullptr, msg);
563 EXPECT_TRUE(upb_test_MapTest_map_string_double_get(msg, test_str_view, &val));
564 EXPECT_EQ(1.5, val);
565 val = 0;
566
567 serialized.data = upb_test_MapTest_serialize(msg, arena, &serialized.size);
568 EXPECT_NE(nullptr, serialized.data);
569
570 msg2 = upb_test_MapTest_parse(serialized.data, serialized.size, arena);
571 ASSERT_NE(nullptr, msg2);
572 EXPECT_TRUE(
573 upb_test_MapTest_map_string_double_get(msg2, test_str_view, &val));
574 EXPECT_EQ(1.5, val);
575
576 upb_Arena_Free(arena);
577 }
578
TEST(GeneratedCode,StringMap)579 TEST(GeneratedCode, StringMap) {
580 upb_Arena* arena = upb_Arena_New();
581 protobuf_test_messages_proto3_TestAllTypesProto3* msg =
582 protobuf_test_messages_proto3_TestAllTypesProto3_new(arena);
583 const protobuf_test_messages_proto3_TestAllTypesProto3_MapStringStringEntry*
584 const_ent;
585 size_t iter, count;
586
587 check_string_map_empty(msg);
588
589 /* Set map[test_str_view] = test_str_view2 */
590 protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_set(
591 msg, test_str_view, test_str_view2, arena);
592 check_string_map_one_entry(msg);
593
594 /* Deleting a non-existent key does nothing. */
595 EXPECT_FALSE(
596 protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_delete(
597 msg, test_str_view3));
598 check_string_map_one_entry(msg);
599
600 /* Deleting the key sets the map back to empty. */
601 EXPECT_TRUE(
602 protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_delete(
603 msg, test_str_view));
604 check_string_map_empty(msg);
605
606 /* Set two keys this time:
607 * map[test_str_view] = test_str_view2
608 * map[test_str_view3] = test_str_view4
609 */
610 protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_set(
611 msg, test_str_view, test_str_view2, arena);
612 protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_set(
613 msg, test_str_view3, test_str_view4, arena);
614
615 /* Test iteration */
616 iter = kUpb_Map_Begin;
617 count = 0;
618
619 while (
620 (const_ent =
621 protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_next(
622 msg, &iter)) != nullptr) {
623 upb_StringView key =
624 protobuf_test_messages_proto3_TestAllTypesProto3_MapStringStringEntry_key(
625 const_ent);
626 upb_StringView val =
627 protobuf_test_messages_proto3_TestAllTypesProto3_MapStringStringEntry_value(
628 const_ent);
629
630 count++;
631 if (upb_StringView_IsEqual(key, test_str_view)) {
632 EXPECT_TRUE(upb_StringView_IsEqual(val, test_str_view2));
633 } else {
634 EXPECT_TRUE(upb_StringView_IsEqual(key, test_str_view3));
635 EXPECT_TRUE(upb_StringView_IsEqual(val, test_str_view4));
636 }
637 }
638
639 EXPECT_EQ(2, count);
640
641 /* Clearing the map goes back to empty. */
642 protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_clear(msg);
643 check_string_map_empty(msg);
644
645 upb_Arena_Free(arena);
646 }
647
check_int32_map_empty(protobuf_test_messages_proto3_TestAllTypesProto3 * msg)648 static void check_int32_map_empty(
649 protobuf_test_messages_proto3_TestAllTypesProto3* msg) {
650 size_t iter = kUpb_Map_Begin;
651
652 EXPECT_EQ(
653 0, protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_size(
654 msg));
655 EXPECT_FALSE(
656 protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_next(
657 msg, &iter));
658 }
659
check_int32_map_one_entry(protobuf_test_messages_proto3_TestAllTypesProto3 * msg)660 static void check_int32_map_one_entry(
661 protobuf_test_messages_proto3_TestAllTypesProto3* msg) {
662 const protobuf_test_messages_proto3_TestAllTypesProto3_MapInt32Int32Entry*
663 const_ent;
664 size_t iter;
665 int32_t val;
666
667 EXPECT_EQ(
668 1, protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_size(
669 msg));
670 EXPECT_TRUE(
671 protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_get(
672 msg, test_int32, &val));
673 EXPECT_EQ(val, test_int32_2);
674
675 EXPECT_FALSE(
676 protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_get(
677 msg, test_int32_3, &val));
678
679 /* Test that iteration reveals a single k/v pair in the map. */
680 iter = kUpb_Map_Begin;
681 const_ent =
682 protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_next(
683 msg, &iter);
684 ASSERT_NE(nullptr, const_ent);
685 EXPECT_EQ(
686 test_int32,
687 protobuf_test_messages_proto3_TestAllTypesProto3_MapInt32Int32Entry_key(
688 const_ent));
689 EXPECT_EQ(
690 test_int32_2,
691 protobuf_test_messages_proto3_TestAllTypesProto3_MapInt32Int32Entry_value(
692 const_ent));
693
694 const_ent =
695 protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_next(
696 msg, &iter);
697 EXPECT_EQ(nullptr, const_ent);
698 }
699
TEST(GeneratedCode,Int32Map)700 TEST(GeneratedCode, Int32Map) {
701 upb_Arena* arena = upb_Arena_New();
702 protobuf_test_messages_proto3_TestAllTypesProto3* msg =
703 protobuf_test_messages_proto3_TestAllTypesProto3_new(arena);
704 const protobuf_test_messages_proto3_TestAllTypesProto3_MapInt32Int32Entry*
705 const_ent;
706 size_t iter, count;
707
708 check_int32_map_empty(msg);
709
710 EXPECT_EQ(
711 _protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_upb_map(
712 msg),
713 nullptr);
714
715 upb_Map* mut_map =
716 _protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_mutable_upb_map(
717 msg, arena);
718 EXPECT_NE(mut_map, nullptr);
719
720 const upb_Map* const_map =
721 _protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_upb_map(
722 msg);
723 EXPECT_EQ(mut_map, const_map);
724
725 /* Set map[test_int32] = test_int32_2 */
726 protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_set(
727 msg, test_int32, test_int32_2, arena);
728 check_int32_map_one_entry(msg);
729
730 /* Deleting a non-existent key does nothing. */
731 EXPECT_FALSE(
732 protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_delete(
733 msg, test_int32_3));
734 check_int32_map_one_entry(msg);
735
736 /* Deleting the key sets the map back to empty. */
737 EXPECT_TRUE(
738 protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_delete(
739 msg, test_int32));
740 check_int32_map_empty(msg);
741
742 /* Set two keys this time:
743 * map[test_int32] = test_int32_2
744 * map[test_int32_3] = test_int32_4
745 */
746 protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_set(
747 msg, test_int32, test_int32_2, arena);
748 protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_set(
749 msg, test_int32_3, test_int32_4, arena);
750
751 /* Test iteration */
752 iter = kUpb_Map_Begin;
753 count = 0;
754
755 while (
756 (const_ent =
757 protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_next(
758 msg, &iter)) != nullptr) {
759 int32_t key =
760 protobuf_test_messages_proto3_TestAllTypesProto3_MapInt32Int32Entry_key(
761 const_ent);
762 int32_t val =
763 protobuf_test_messages_proto3_TestAllTypesProto3_MapInt32Int32Entry_value(
764 const_ent);
765
766 count++;
767 if (key == test_int32) {
768 EXPECT_EQ(val, test_int32_2);
769 } else {
770 EXPECT_EQ(key, test_int32_3);
771 EXPECT_EQ(val, test_int32_4);
772 }
773 }
774
775 EXPECT_EQ(2, count);
776
777 /* Clearing the map goes back to empty. */
778 protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_clear(msg);
779 check_int32_map_empty(msg);
780
781 upb_Arena_Free(arena);
782 }
783
TEST(GeneratedCode,TestRepeated)784 TEST(GeneratedCode, TestRepeated) {
785 upb_Arena* arena = upb_Arena_New();
786 protobuf_test_messages_proto3_TestAllTypesProto3* msg =
787 protobuf_test_messages_proto3_TestAllTypesProto3_new(arena);
788 size_t size;
789 const int* elems;
790
791 EXPECT_EQ(
792 _protobuf_test_messages_proto3_TestAllTypesProto3_repeated_int32_upb_array(
793 msg, &size),
794 nullptr);
795
796 protobuf_test_messages_proto3_TestAllTypesProto3_add_repeated_int32(msg, 5,
797 arena);
798
799 EXPECT_NE(
800 _protobuf_test_messages_proto3_TestAllTypesProto3_repeated_int32_upb_array(
801 msg, &size),
802 nullptr);
803
804 elems = protobuf_test_messages_proto3_TestAllTypesProto3_repeated_int32(
805 msg, &size);
806
807 EXPECT_EQ(size, 1);
808 EXPECT_EQ(elems[0], 5);
809
810 const upb_Array* arr =
811 _protobuf_test_messages_proto3_TestAllTypesProto3_repeated_int32_upb_array(
812 msg, &size);
813 EXPECT_EQ(size, 1);
814 upb_Array* mutable_arr =
815 _protobuf_test_messages_proto3_TestAllTypesProto3_repeated_int32_mutable_upb_array(
816 msg, &size, arena);
817 EXPECT_EQ(mutable_arr, arr);
818 EXPECT_EQ(upb_Array_Size(arr), 1);
819 EXPECT_EQ(size, 1);
820
821 upb_Arena_Free(arena);
822 }
823
TEST(GeneratedCode,Issue9440)824 TEST(GeneratedCode, Issue9440) {
825 upb::Arena arena;
826 upb_test_HelloRequest* msg = upb_test_HelloRequest_new(arena.ptr());
827 upb_test_HelloRequest_set_id(msg, 8);
828 EXPECT_EQ(8, upb_test_HelloRequest_id(msg));
829 char str[] = "1";
830 upb_test_HelloRequest_set_version(msg, upb_StringView{str, strlen(str)});
831 EXPECT_EQ(8, upb_test_HelloRequest_id(msg));
832 }
833
TEST(GeneratedCode,NullDecodeBuffer)834 TEST(GeneratedCode, NullDecodeBuffer) {
835 upb_Arena* arena = upb_Arena_New();
836 protobuf_test_messages_proto3_TestAllTypesProto3* msg =
837 protobuf_test_messages_proto3_TestAllTypesProto3_parse(nullptr, 0, arena);
838 size_t size;
839
840 ASSERT_NE(nullptr, msg);
841 protobuf_test_messages_proto3_TestAllTypesProto3_serialize(msg, arena, &size);
842 EXPECT_EQ(0, size);
843 upb_Arena_Free(arena);
844 }
845
TEST(GeneratedCode,StatusTruncation)846 TEST(GeneratedCode, StatusTruncation) {
847 int i, j;
848 upb_Status status;
849 upb_Status status2;
850 for (i = 0; i < _kUpb_Status_MaxMessage + 20; i++) {
851 char* msg = static_cast<char*>(malloc(i + 1));
852 int end;
853 char ch = (i % 96) + 33; /* Cycle through printable chars. */
854
855 for (j = 0; j < i; j++) {
856 msg[j] = ch;
857 }
858 msg[i] = '\0';
859
860 upb_Status_SetErrorMessage(&status, msg);
861 upb_Status_SetErrorFormat(&status2, "%s", msg);
862 end = MIN(i, _kUpb_Status_MaxMessage - 1);
863 EXPECT_EQ(end, strlen(status.msg));
864 EXPECT_EQ(end, strlen(status2.msg));
865
866 for (j = 0; j < end; j++) {
867 EXPECT_EQ(ch, status.msg[j]);
868 EXPECT_EQ(ch, status2.msg[j]);
869 }
870
871 free(msg);
872 }
873 }
874
TEST(GeneratedCode,ArenaUnaligned)875 TEST(GeneratedCode, ArenaUnaligned) {
876 char buf1[1024];
877 // Force the pointer to be unaligned.
878 uintptr_t low_bits = UPB_MALLOC_ALIGN - 1;
879 char* unaligned_buf_ptr = (char*)((uintptr_t)buf1 | low_bits);
880 upb_Arena* arena = upb_Arena_Init(
881 unaligned_buf_ptr, &buf1[sizeof(buf1)] - unaligned_buf_ptr, nullptr);
882 char* mem = static_cast<char*>(upb_Arena_Malloc(arena, 5));
883 EXPECT_EQ(0, reinterpret_cast<uintptr_t>(mem) & low_bits);
884 upb_Arena_Free(arena);
885
886 // Try the same, but with a size so small that aligning up will overflow.
887 arena = upb_Arena_Init(unaligned_buf_ptr, 5, &upb_alloc_global);
888 mem = static_cast<char*>(upb_Arena_Malloc(arena, 5));
889 EXPECT_EQ(0, reinterpret_cast<uintptr_t>(mem) & low_bits);
890 upb_Arena_Free(arena);
891 }
892
TEST(GeneratedCode,Extensions)893 TEST(GeneratedCode, Extensions) {
894 upb::Arena arena;
895 upb_test_ModelExtension1* extension1 =
896 upb_test_ModelExtension1_new(arena.ptr());
897 upb_test_ModelExtension1_set_str(extension1,
898 upb_StringView_FromString("Hello"));
899
900 upb_test_ModelExtension2* extension2 =
901 upb_test_ModelExtension2_new(arena.ptr());
902 upb_test_ModelExtension2_set_i(extension2, 5);
903
904 upb_test_ModelWithExtensions* msg1 =
905 upb_test_ModelWithExtensions_new(arena.ptr());
906 upb_test_ModelWithExtensions* msg2 =
907 upb_test_ModelWithExtensions_new(arena.ptr());
908
909 // msg1: [extension1, extension2]
910 upb_test_ModelExtension1_set_model_ext(msg1, extension1, arena.ptr());
911 upb_test_ModelExtension2_set_model_ext(msg1, extension2, arena.ptr());
912
913 // msg2: [extension2, extension1]
914 upb_test_ModelExtension2_set_model_ext(msg2, extension2, arena.ptr());
915 upb_test_ModelExtension1_set_model_ext(msg2, extension1, arena.ptr());
916
917 size_t size1, size2;
918 int opts = kUpb_EncodeOption_Deterministic;
919 char* pb1 = upb_test_ModelWithExtensions_serialize_ex(msg1, opts, arena.ptr(),
920 &size1);
921 char* pb2 = upb_test_ModelWithExtensions_serialize_ex(msg2, opts, arena.ptr(),
922 &size2);
923
924 ASSERT_EQ(size1, size2);
925 ASSERT_EQ(0, memcmp(pb1, pb2, size1));
926 }
927
TEST(GeneratedCode,Maps)928 TEST(GeneratedCode, Maps) {
929 upb::Arena arena;
930 upb_test_ModelWithMaps* msg = upb_test_ModelWithMaps_new(arena.ptr());
931
932 auto sb = _upb_test_ModelWithMaps_map_sb_mutable_upb_map(msg, arena.ptr());
933 auto ss = _upb_test_ModelWithMaps_map_ss_mutable_upb_map(msg, arena.ptr());
934 auto ii = _upb_test_ModelWithMaps_map_ii_mutable_upb_map(msg, arena.ptr());
935
936 ASSERT_NE(sb, nullptr);
937 ASSERT_NE(ss, nullptr);
938 ASSERT_NE(ii, nullptr);
939
940 upb_MessageValue key, val;
941 key.str_val = test_str_view;
942 val.str_val = test_str_view2;
943
944 upb_Map_Set(sb, key, val, arena.ptr());
945 }
946