protobuf/src/google/protobuf/reflection_ops_unittest.cc
Go to the documentation of this file.
1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved.
3 // https://developers.google.com/protocol-buffers/
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 // * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 // * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 
31 // Author: kenton@google.com (Kenton Varda)
32 // Based on original Protocol Buffers design by
33 // Sanjay Ghemawat, Jeff Dean, and others.
34 
35 #include <google/protobuf/reflection_ops.h>
36 #include <google/protobuf/test_util.h>
37 #include <google/protobuf/unittest.pb.h>
38 #include <google/protobuf/descriptor.h>
39 
40 #include <google/protobuf/stubs/logging.h>
41 #include <google/protobuf/stubs/common.h>
42 #include <google/protobuf/testing/googletest.h>
43 #include <gtest/gtest.h>
44 
45 #include <google/protobuf/stubs/strutil.h>
46 
47 namespace google {
48 namespace protobuf {
49 namespace internal {
50 namespace {
51 
52 TEST(ReflectionOpsTest, SanityCheck) {
53  unittest::TestAllTypes message;
54 
55  TestUtil::SetAllFields(&message);
56  TestUtil::ExpectAllFieldsSet(message);
57 }
58 
59 TEST(ReflectionOpsTest, Copy) {
60  unittest::TestAllTypes message, message2;
61 
62  TestUtil::SetAllFields(&message);
63 
64  ReflectionOps::Copy(message, &message2);
65 
66  TestUtil::ExpectAllFieldsSet(message2);
67 
68  // Copying from self should be a no-op.
69  ReflectionOps::Copy(message2, &message2);
70  TestUtil::ExpectAllFieldsSet(message2);
71 }
72 
73 TEST(ReflectionOpsTest, CopyExtensions) {
74  unittest::TestAllExtensions message, message2;
75 
76  TestUtil::SetAllExtensions(&message);
77 
78  ReflectionOps::Copy(message, &message2);
79 
80  TestUtil::ExpectAllExtensionsSet(message2);
81 }
82 
83 TEST(ReflectionOpsTest, CopyOneof) {
84  unittest::TestOneof2 message, message2;
85  TestUtil::SetOneof1(&message);
86  ReflectionOps::Copy(message, &message2);
87  TestUtil::ExpectOneofSet1(message2);
88 
89  TestUtil::SetOneof2(&message);
90  TestUtil::ExpectOneofSet2(message);
91  ReflectionOps::Copy(message, &message2);
92  TestUtil::ExpectOneofSet2(message2);
93 }
94 
95 TEST(ReflectionOpsTest, Merge) {
96  // Note: Copy is implemented in terms of Merge() so technically the Copy
97  // test already tested most of this.
98 
99  unittest::TestAllTypes message, message2;
100 
101  TestUtil::SetAllFields(&message);
102 
103  // This field will test merging into an empty spot.
104  message2.set_optional_int32(message.optional_int32());
105  message.clear_optional_int32();
106 
107  // This tests overwriting.
108  message2.set_optional_string(message.optional_string());
109  message.set_optional_string("something else");
110 
111  // This tests concatenating.
112  message2.add_repeated_int32(message.repeated_int32(1));
113  int32 i = message.repeated_int32(0);
114  message.clear_repeated_int32();
115  message.add_repeated_int32(i);
116 
117  ReflectionOps::Merge(message2, &message);
118 
119  TestUtil::ExpectAllFieldsSet(message);
120 }
121 
122 TEST(ReflectionOpsTest, MergeExtensions) {
123  // Note: Copy is implemented in terms of Merge() so technically the Copy
124  // test already tested most of this.
125 
126  unittest::TestAllExtensions message, message2;
127 
128  TestUtil::SetAllExtensions(&message);
129 
130  // This field will test merging into an empty spot.
131  message2.SetExtension(
132  unittest::optional_int32_extension,
133  message.GetExtension(unittest::optional_int32_extension));
134  message.ClearExtension(unittest::optional_int32_extension);
135 
136  // This tests overwriting.
137  message2.SetExtension(
138  unittest::optional_string_extension,
139  message.GetExtension(unittest::optional_string_extension));
140  message.SetExtension(unittest::optional_string_extension, "something else");
141 
142  // This tests concatenating.
143  message2.AddExtension(
144  unittest::repeated_int32_extension,
145  message.GetExtension(unittest::repeated_int32_extension, 1));
146  int32 i = message.GetExtension(unittest::repeated_int32_extension, 0);
147  message.ClearExtension(unittest::repeated_int32_extension);
148  message.AddExtension(unittest::repeated_int32_extension, i);
149 
150  ReflectionOps::Merge(message2, &message);
151 
152  TestUtil::ExpectAllExtensionsSet(message);
153 }
154 
155 TEST(ReflectionOpsTest, MergeUnknown) {
156  // Test that the messages' UnknownFieldSets are correctly merged.
157  unittest::TestEmptyMessage message1, message2;
158  message1.mutable_unknown_fields()->AddVarint(1234, 1);
159  message2.mutable_unknown_fields()->AddVarint(1234, 2);
160 
161  ReflectionOps::Merge(message2, &message1);
162 
163  ASSERT_EQ(2, message1.unknown_fields().field_count());
164  ASSERT_EQ(UnknownField::TYPE_VARINT,
165  message1.unknown_fields().field(0).type());
166  EXPECT_EQ(1, message1.unknown_fields().field(0).varint());
167  ASSERT_EQ(UnknownField::TYPE_VARINT,
168  message1.unknown_fields().field(1).type());
169  EXPECT_EQ(2, message1.unknown_fields().field(1).varint());
170 }
171 
172 TEST(ReflectionOpsTest, MergeOneof) {
173  unittest::TestOneof2 message1, message2;
174  TestUtil::SetOneof1(&message1);
175 
176  // Merge to empty message
177  ReflectionOps::Merge(message1, &message2);
178  TestUtil::ExpectOneofSet1(message2);
179 
180  // Merge with the same oneof fields
181  ReflectionOps::Merge(message1, &message2);
182  TestUtil::ExpectOneofSet1(message2);
183 
184  // Merge with different oneof fields
185  TestUtil::SetOneof2(&message1);
186  ReflectionOps::Merge(message1, &message2);
187  TestUtil::ExpectOneofSet2(message2);
188 }
189 
190 #ifdef PROTOBUF_HAS_DEATH_TEST
191 
192 TEST(ReflectionOpsTest, MergeFromSelf) {
193  // Note: Copy is implemented in terms of Merge() so technically the Copy
194  // test already tested most of this.
195 
196  unittest::TestAllTypes message;
197 
198  EXPECT_DEATH(ReflectionOps::Merge(message, &message), "&from");
199 }
200 
201 #endif // PROTOBUF_HAS_DEATH_TEST
202 
203 TEST(ReflectionOpsTest, Clear) {
204  unittest::TestAllTypes message;
205 
206  TestUtil::SetAllFields(&message);
207 
208  ReflectionOps::Clear(&message);
209 
210  TestUtil::ExpectClear(message);
211 
212  // Check that getting embedded messages returns the objects created during
213  // SetAllFields() rather than default instances.
214  EXPECT_NE(&unittest::TestAllTypes::OptionalGroup::default_instance(),
215  &message.optionalgroup());
216  EXPECT_NE(&unittest::TestAllTypes::NestedMessage::default_instance(),
217  &message.optional_nested_message());
218  EXPECT_NE(&unittest::ForeignMessage::default_instance(),
219  &message.optional_foreign_message());
220  EXPECT_NE(&unittest_import::ImportMessage::default_instance(),
221  &message.optional_import_message());
222 }
223 
224 TEST(ReflectionOpsTest, ClearExtensions) {
225  unittest::TestAllExtensions message;
226 
227  TestUtil::SetAllExtensions(&message);
228 
229  ReflectionOps::Clear(&message);
230 
231  TestUtil::ExpectExtensionsClear(message);
232 
233  // Check that getting embedded messages returns the objects created during
234  // SetAllExtensions() rather than default instances.
235  EXPECT_NE(&unittest::OptionalGroup_extension::default_instance(),
236  &message.GetExtension(unittest::optionalgroup_extension));
237  EXPECT_NE(&unittest::TestAllTypes::NestedMessage::default_instance(),
238  &message.GetExtension(unittest::optional_nested_message_extension));
239  EXPECT_NE(
240  &unittest::ForeignMessage::default_instance(),
241  &message.GetExtension(unittest::optional_foreign_message_extension));
242  EXPECT_NE(&unittest_import::ImportMessage::default_instance(),
243  &message.GetExtension(unittest::optional_import_message_extension));
244 }
245 
246 TEST(ReflectionOpsTest, ClearUnknown) {
247  // Test that the message's UnknownFieldSet is correctly cleared.
248  unittest::TestEmptyMessage message;
249  message.mutable_unknown_fields()->AddVarint(1234, 1);
250 
251  ReflectionOps::Clear(&message);
252 
253  EXPECT_EQ(0, message.unknown_fields().field_count());
254 }
255 
256 TEST(ReflectionOpsTest, ClearOneof) {
257  unittest::TestOneof2 message;
258 
259  TestUtil::ExpectOneofClear(message);
260  TestUtil::SetOneof1(&message);
261  TestUtil::ExpectOneofSet1(message);
262  ReflectionOps::Clear(&message);
263  TestUtil::ExpectOneofClear(message);
264 
265  TestUtil::SetOneof1(&message);
266  TestUtil::ExpectOneofSet1(message);
267  TestUtil::SetOneof2(&message);
268  TestUtil::ExpectOneofSet2(message);
269  ReflectionOps::Clear(&message);
270  TestUtil::ExpectOneofClear(message);
271 }
272 
273 TEST(ReflectionOpsTest, DiscardUnknownFields) {
274  unittest::TestAllTypes message;
275  TestUtil::SetAllFields(&message);
276 
277  // Set some unknown fields in message.
278  message.mutable_unknown_fields()->AddVarint(123456, 654321);
279  message.mutable_optional_nested_message()
280  ->mutable_unknown_fields()
281  ->AddVarint(123456, 654321);
282  message.mutable_repeated_nested_message(0)
283  ->mutable_unknown_fields()
284  ->AddVarint(123456, 654321);
285 
286  EXPECT_EQ(1, message.unknown_fields().field_count());
287  EXPECT_EQ(1,
288  message.optional_nested_message().unknown_fields().field_count());
289  EXPECT_EQ(1,
290  message.repeated_nested_message(0).unknown_fields().field_count());
291 
292  // Discard them.
293  ReflectionOps::DiscardUnknownFields(&message);
294  TestUtil::ExpectAllFieldsSet(message);
295 
296  EXPECT_EQ(0, message.unknown_fields().field_count());
297  EXPECT_EQ(0,
298  message.optional_nested_message().unknown_fields().field_count());
299  EXPECT_EQ(0,
300  message.repeated_nested_message(0).unknown_fields().field_count());
301 }
302 
303 TEST(ReflectionOpsTest, DiscardUnknownExtensions) {
304  unittest::TestAllExtensions message;
305  TestUtil::SetAllExtensions(&message);
306 
307  // Set some unknown fields.
308  message.mutable_unknown_fields()->AddVarint(123456, 654321);
309  message.MutableExtension(unittest::optional_nested_message_extension)
310  ->mutable_unknown_fields()
311  ->AddVarint(123456, 654321);
312  message.MutableExtension(unittest::repeated_nested_message_extension, 0)
313  ->mutable_unknown_fields()
314  ->AddVarint(123456, 654321);
315 
316  EXPECT_EQ(1, message.unknown_fields().field_count());
317  EXPECT_EQ(1, message.GetExtension(unittest::optional_nested_message_extension)
318  .unknown_fields()
319  .field_count());
320  EXPECT_EQ(1,
321  message.GetExtension(unittest::repeated_nested_message_extension, 0)
322  .unknown_fields()
323  .field_count());
324 
325  // Discard them.
326  ReflectionOps::DiscardUnknownFields(&message);
327  TestUtil::ExpectAllExtensionsSet(message);
328 
329  EXPECT_EQ(0, message.unknown_fields().field_count());
330  EXPECT_EQ(0, message.GetExtension(unittest::optional_nested_message_extension)
331  .unknown_fields()
332  .field_count());
333  EXPECT_EQ(0,
334  message.GetExtension(unittest::repeated_nested_message_extension, 0)
335  .unknown_fields()
336  .field_count());
337 }
338 
339 TEST(ReflectionOpsTest, IsInitialized) {
340  unittest::TestRequired message;
341 
342  EXPECT_FALSE(ReflectionOps::IsInitialized(message));
343  EXPECT_FALSE(ReflectionOps::IsInitialized(message, true, false));
344  EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
345  message.set_a(1);
346  EXPECT_FALSE(ReflectionOps::IsInitialized(message));
347  EXPECT_FALSE(ReflectionOps::IsInitialized(message, true, true));
348  EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
349  message.set_b(2);
350  EXPECT_FALSE(ReflectionOps::IsInitialized(message));
351  EXPECT_FALSE(ReflectionOps::IsInitialized(message, true, true));
352  EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
353  message.set_c(3);
354  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
355  EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
356  EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
357 }
358 
359 TEST(ReflectionOpsTest, ForeignIsInitialized) {
360  unittest::TestRequiredForeign message;
361 
362  // Starts out initialized because the foreign message is itself an optional
363  // field.
364  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
365  EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
366 
367  // Once we create that field, the message is no longer initialized.
368  message.mutable_optional_message();
369  EXPECT_FALSE(ReflectionOps::IsInitialized(message));
370  EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
371  EXPECT_FALSE(ReflectionOps::IsInitialized(message, false, true));
372 
373  // Initialize it. Now we're initialized.
374  message.mutable_optional_message()->set_a(1);
375  message.mutable_optional_message()->set_b(2);
376  message.mutable_optional_message()->set_c(3);
377  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
378  EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
379  EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
380 
381  // Add a repeated version of the message. No longer initialized.
382  unittest::TestRequired* sub_message = message.add_repeated_message();
383  EXPECT_FALSE(ReflectionOps::IsInitialized(message));
384  EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
385  EXPECT_FALSE(ReflectionOps::IsInitialized(message, false, true));
386 
387  // Initialize that repeated version.
388  sub_message->set_a(1);
389  sub_message->set_b(2);
390  sub_message->set_c(3);
391  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
392  EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
393  EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
394 }
395 
396 TEST(ReflectionOpsTest, ExtensionIsInitialized) {
397  unittest::TestAllExtensions message;
398 
399  // Starts out initialized because the foreign message is itself an optional
400  // field.
401  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
402  EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
403  EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
404 
405  // Once we create that field, the message is no longer initialized.
406  message.MutableExtension(unittest::TestRequired::single);
407  EXPECT_FALSE(ReflectionOps::IsInitialized(message));
408  EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
409  EXPECT_FALSE(ReflectionOps::IsInitialized(message, false, true));
410 
411  // Initialize it. Now we're initialized.
412  message.MutableExtension(unittest::TestRequired::single)->set_a(1);
413  message.MutableExtension(unittest::TestRequired::single)->set_b(2);
414  message.MutableExtension(unittest::TestRequired::single)->set_c(3);
415  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
416  EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
417  EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
418 
419  // Add a repeated version of the message. No longer initialized.
420  message.AddExtension(unittest::TestRequired::multi);
421  EXPECT_FALSE(ReflectionOps::IsInitialized(message));
422  EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
423  EXPECT_FALSE(ReflectionOps::IsInitialized(message, false, true));
424 
425  // Initialize that repeated version.
426  message.MutableExtension(unittest::TestRequired::multi, 0)->set_a(1);
427  message.MutableExtension(unittest::TestRequired::multi, 0)->set_b(2);
428  message.MutableExtension(unittest::TestRequired::multi, 0)->set_c(3);
429  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
430  EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
431  EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
432 }
433 
434 TEST(ReflectionOpsTest, OneofIsInitialized) {
435  unittest::TestRequiredOneof message;
436  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
437  EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
438  EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
439 
440  message.mutable_foo_message();
441  EXPECT_FALSE(ReflectionOps::IsInitialized(message));
442  EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
443  EXPECT_FALSE(ReflectionOps::IsInitialized(message, false, true));
444 
445  message.set_foo_int(1);
446  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
447  EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
448  EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
449 
450  message.mutable_foo_message();
451  EXPECT_FALSE(ReflectionOps::IsInitialized(message));
452  EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
453  EXPECT_FALSE(ReflectionOps::IsInitialized(message, false, true));
454  message.mutable_foo_message()->set_required_double(0.1);
455  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
456  EXPECT_TRUE(ReflectionOps::IsInitialized(message, true, false));
457  EXPECT_TRUE(ReflectionOps::IsInitialized(message, false, true));
458 }
459 
460 static std::string FindInitializationErrors(const Message& message) {
461  std::vector<std::string> errors;
462  ReflectionOps::FindInitializationErrors(message, "", &errors);
463  return Join(errors, ",");
464 }
465 
466 TEST(ReflectionOpsTest, FindInitializationErrors) {
467  unittest::TestRequired message;
468  EXPECT_EQ("a,b,c", FindInitializationErrors(message));
469 }
470 
471 TEST(ReflectionOpsTest, FindForeignInitializationErrors) {
472  unittest::TestRequiredForeign message;
473  message.mutable_optional_message();
474  message.add_repeated_message();
475  message.add_repeated_message();
476  EXPECT_EQ(
477  "optional_message.a,"
478  "optional_message.b,"
479  "optional_message.c,"
480  "repeated_message[0].a,"
481  "repeated_message[0].b,"
482  "repeated_message[0].c,"
483  "repeated_message[1].a,"
484  "repeated_message[1].b,"
485  "repeated_message[1].c",
486  FindInitializationErrors(message));
487 }
488 
489 TEST(ReflectionOpsTest, FindExtensionInitializationErrors) {
490  unittest::TestAllExtensions message;
491  message.MutableExtension(unittest::TestRequired::single);
492  message.AddExtension(unittest::TestRequired::multi);
493  message.AddExtension(unittest::TestRequired::multi);
494  EXPECT_EQ(
495  "(protobuf_unittest.TestRequired.single).a,"
496  "(protobuf_unittest.TestRequired.single).b,"
497  "(protobuf_unittest.TestRequired.single).c,"
498  "(protobuf_unittest.TestRequired.multi)[0].a,"
499  "(protobuf_unittest.TestRequired.multi)[0].b,"
500  "(protobuf_unittest.TestRequired.multi)[0].c,"
501  "(protobuf_unittest.TestRequired.multi)[1].a,"
502  "(protobuf_unittest.TestRequired.multi)[1].b,"
503  "(protobuf_unittest.TestRequired.multi)[1].c",
504  FindInitializationErrors(message));
505 }
506 
507 TEST(ReflectionOpsTest, FindOneofInitializationErrors) {
508  unittest::TestRequiredOneof message;
509  message.mutable_foo_message();
510  EXPECT_EQ("foo_message.required_double", FindInitializationErrors(message));
511 }
512 
513 TEST(ReflectionOpsTest, GenericSwap) {
514  Arena arena;
515  {
516  unittest::TestAllTypes message;
517  auto* arena_message = Arena::CreateMessage<unittest::TestAllTypes>(&arena);
518  TestUtil::SetAllFields(arena_message);
519  const uint64 initial_arena_size = arena.SpaceUsed();
520 
521  GenericSwap(&message, arena_message);
522 
523  TestUtil::ExpectAllFieldsSet(message);
524  TestUtil::ExpectClear(*arena_message);
525  // The temp should be allocated on the arena in this case.
526  EXPECT_GT(arena.SpaceUsed(), initial_arena_size);
527  }
528  {
529  unittest::TestAllTypes message;
530  auto* arena_message = Arena::CreateMessage<unittest::TestAllTypes>(&arena);
531  TestUtil::SetAllFields(arena_message);
532  const uint64 initial_arena_size = arena.SpaceUsed();
533 
534  GenericSwap(arena_message, &message);
535 
536  TestUtil::ExpectAllFieldsSet(message);
537  TestUtil::ExpectClear(*arena_message);
538  // The temp should be allocated on the arena in this case.
539  EXPECT_GT(arena.SpaceUsed(), initial_arena_size);
540  }
541 }
542 
543 } // namespace
544 } // namespace internal
545 } // namespace protobuf
546 } // namespace google
EXPECT_FALSE
#define EXPECT_FALSE(condition)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:1970
tests.google.protobuf.internal.test_util.SetAllExtensions
def SetAllExtensions(message)
Definition: bloaty/third_party/protobuf/python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/test_util.py:187
google::protobuf.internal.python_message.DiscardUnknownFields
DiscardUnknownFields
Definition: bloaty/third_party/protobuf/python/google/protobuf/internal/python_message.py:1432
EXPECT_GT
#define EXPECT_GT(val1, val2)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:2036
Arena
Definition: arena.c:39
testing::internal::string
::std::string string
Definition: bloaty/third_party/protobuf/third_party/googletest/googletest/include/gtest/internal/gtest-port.h:881
google::protobuf
Definition: bloaty/third_party/protobuf/benchmarks/util/data_proto2_to_proto3_util.h:12
google::protobuf.internal::GenericSwap
void GenericSwap(MessageLite *m1, MessageLite *m2)
Definition: bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc:735
message
char * message
Definition: libuv/docs/code/tty-gravity/main.c:12
arena
grpc_core::ScopedArenaPtr arena
Definition: binder_transport_test.cc:237
tests.google.protobuf.internal.test_util.SetAllFields
def SetAllFields(message)
Definition: bloaty/third_party/protobuf/python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/test_util.py:182
EXPECT_EQ
#define EXPECT_EQ(a, b)
Definition: iomgr/time_averaged_stats_test.cc:27
google::protobuf.internal::ReflectionOps::FindInitializationErrors
static void FindInitializationErrors(const Message &message, const std::string &prefix, std::vector< std::string > *errors)
Definition: bloaty/third_party/protobuf/src/google/protobuf/reflection_ops.cc:302
google::protobuf.internal::ReflectionOps::Merge
static void Merge(const Message &from, Message *to)
Definition: bloaty/third_party/protobuf/src/google/protobuf/reflection_ops.cc:71
google::protobuf::int32
int32_t int32
Definition: third_party/bloaty/third_party/protobuf/src/google/protobuf/stubs/port.h:150
errors
const char * errors
Definition: bloaty/third_party/protobuf/src/google/protobuf/io/tokenizer_unittest.cc:841
EXPECT_NE
#define EXPECT_NE(val1, val2)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:2028
google::protobuf.internal::ReflectionOps::DiscardUnknownFields
static void DiscardUnknownFields(Message *message)
Definition: bloaty/third_party/protobuf/src/google/protobuf/reflection_ops.cc:242
google::protobuf::uint64
uint64_t uint64
Definition: third_party/bloaty/third_party/protobuf/src/google/protobuf/stubs/port.h:156
tests.google.protobuf.internal.test_util.ExpectAllFieldsSet
def ExpectAllFieldsSet(test_case, message)
Definition: bloaty/third_party/protobuf/python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/test_util.py:367
google::protobuf::UnknownField::TYPE_VARINT
@ TYPE_VARINT
Definition: bloaty/third_party/protobuf/src/google/protobuf/unknown_field_set.h:219
google::protobuf.text_format.Merge
def Merge(text, message, allow_unknown_extension=False, allow_field_number=False, descriptor_pool=None, allow_unknown_field=False)
Definition: bloaty/third_party/protobuf/python/google/protobuf/text_format.py:659
google::protobuf.internal.python_message.Clear
Clear
Definition: bloaty/third_party/protobuf/python/google/protobuf/internal/python_message.py:1430
Copy
@ Copy
Definition: upb/benchmarks/benchmark.cc:200
google::protobuf.internal::TEST
TEST(GeneratedMapFieldTest, Accessors)
Definition: third_party/bloaty/third_party/protobuf/src/google/protobuf/map_test.cc:1847
google::protobuf.internal.python_message.IsInitialized
IsInitialized
Definition: bloaty/third_party/protobuf/python/google/protobuf/internal/python_message.py:1245
google::protobuf.internal::ReflectionOps::Copy
static void Copy(const Message &from, Message *to)
Definition: bloaty/third_party/protobuf/src/google/protobuf/reflection_ops.cc:65
EXPECT_TRUE
#define EXPECT_TRUE(condition)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:1967
internal
Definition: benchmark/test/output_test_helper.cc:20
google::protobuf::Join
void Join(Iterator start, Iterator end, const char *delim, string *result)
Definition: bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.h:769
google::protobuf.internal::ReflectionOps::IsInitialized
static bool IsInitialized(const Message &message)
Definition: bloaty/third_party/protobuf/src/google/protobuf/reflection_ops.cc:176
google
Definition: bloaty/third_party/protobuf/benchmarks/util/data_proto2_to_proto3_util.h:11
Message
Definition: protobuf/php/ext/google/protobuf/message.c:53
google::protobuf.internal::ReflectionOps::Clear
static void Clear(Message *message)
Definition: bloaty/third_party/protobuf/src/google/protobuf/reflection_ops.cc:164
i
uint64_t i
Definition: abseil-cpp/absl/container/btree_benchmark.cc:230
ASSERT_EQ
#define ASSERT_EQ(val1, val2)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:2056
google::protobuf.internal.python_message.FindInitializationErrors
FindInitializationErrors
Definition: bloaty/third_party/protobuf/python/google/protobuf/internal/python_message.py:1291

grpc
Author(s):
autogenerated on Fri May 16 2025 03:00:01