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