/thirdparty/breakpad/third_party/protobuf/protobuf/src/google/protobuf/reflection_ops_unittest.cc

  1// Protocol Buffers - Google's data interchange format
  2// Copyright 2008 Google Inc.  All rights reserved.
  3// http://code.google.com/p/protobuf/
  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/descriptor.h>
 37#include <google/protobuf/unittest.pb.h>
 38#include <google/protobuf/test_util.h>
 39
 40#include <google/protobuf/stubs/common.h>
 41#include <google/protobuf/testing/googletest.h>
 42#include <gtest/gtest.h>
 43#include <google/protobuf/stubs/strutil.h>
 44
 45namespace google {
 46namespace protobuf {
 47namespace internal {
 48namespace {
 49
 50TEST(ReflectionOpsTest, SanityCheck) {
 51  unittest::TestAllTypes message;
 52
 53  TestUtil::SetAllFields(&message);
 54  TestUtil::ExpectAllFieldsSet(message);
 55}
 56
 57TEST(ReflectionOpsTest, Copy) {
 58  unittest::TestAllTypes message, message2;
 59
 60  TestUtil::SetAllFields(&message);
 61
 62  ReflectionOps::Copy(message, &message2);
 63
 64  TestUtil::ExpectAllFieldsSet(message2);
 65
 66  // Copying from self should be a no-op.
 67  ReflectionOps::Copy(message2, &message2);
 68  TestUtil::ExpectAllFieldsSet(message2);
 69}
 70
 71TEST(ReflectionOpsTest, CopyExtensions) {
 72  unittest::TestAllExtensions message, message2;
 73
 74  TestUtil::SetAllExtensions(&message);
 75
 76  ReflectionOps::Copy(message, &message2);
 77
 78  TestUtil::ExpectAllExtensionsSet(message2);
 79}
 80
 81TEST(ReflectionOpsTest, Merge) {
 82  // Note:  Copy is implemented in terms of Merge() so technically the Copy
 83  //   test already tested most of this.
 84
 85  unittest::TestAllTypes message, message2;
 86
 87  TestUtil::SetAllFields(&message);
 88
 89  // This field will test merging into an empty spot.
 90  message2.set_optional_int32(message.optional_int32());
 91  message.clear_optional_int32();
 92
 93  // This tests overwriting.
 94  message2.set_optional_string(message.optional_string());
 95  message.set_optional_string("something else");
 96
 97  // This tests concatenating.
 98  message2.add_repeated_int32(message.repeated_int32(1));
 99  int32 i = message.repeated_int32(0);
100  message.clear_repeated_int32();
101  message.add_repeated_int32(i);
102
103  ReflectionOps::Merge(message2, &message);
104
105  TestUtil::ExpectAllFieldsSet(message);
106}
107
108TEST(ReflectionOpsTest, MergeExtensions) {
109  // Note:  Copy is implemented in terms of Merge() so technically the Copy
110  //   test already tested most of this.
111
112  unittest::TestAllExtensions message, message2;
113
114  TestUtil::SetAllExtensions(&message);
115
116  // This field will test merging into an empty spot.
117  message2.SetExtension(unittest::optional_int32_extension,
118    message.GetExtension(unittest::optional_int32_extension));
119  message.ClearExtension(unittest::optional_int32_extension);
120
121  // This tests overwriting.
122  message2.SetExtension(unittest::optional_string_extension,
123    message.GetExtension(unittest::optional_string_extension));
124  message.SetExtension(unittest::optional_string_extension, "something else");
125
126  // This tests concatenating.
127  message2.AddExtension(unittest::repeated_int32_extension,
128    message.GetExtension(unittest::repeated_int32_extension, 1));
129  int32 i = message.GetExtension(unittest::repeated_int32_extension, 0);
130  message.ClearExtension(unittest::repeated_int32_extension);
131  message.AddExtension(unittest::repeated_int32_extension, i);
132
133  ReflectionOps::Merge(message2, &message);
134
135  TestUtil::ExpectAllExtensionsSet(message);
136}
137
138TEST(ReflectionOpsTest, MergeUnknown) {
139  // Test that the messages' UnknownFieldSets are correctly merged.
140  unittest::TestEmptyMessage message1, message2;
141  message1.mutable_unknown_fields()->AddVarint(1234, 1);
142  message2.mutable_unknown_fields()->AddVarint(1234, 2);
143
144  ReflectionOps::Merge(message2, &message1);
145
146  ASSERT_EQ(2, message1.unknown_fields().field_count());
147  ASSERT_EQ(UnknownField::TYPE_VARINT,
148            message1.unknown_fields().field(0).type());
149  EXPECT_EQ(1, message1.unknown_fields().field(0).varint());
150  ASSERT_EQ(UnknownField::TYPE_VARINT,
151            message1.unknown_fields().field(1).type());
152  EXPECT_EQ(2, message1.unknown_fields().field(1).varint());
153}
154
155#ifdef GTEST_HAS_DEATH_TEST
156
157TEST(ReflectionOpsTest, MergeFromSelf) {
158  // Note:  Copy is implemented in terms of Merge() so technically the Copy
159  //   test already tested most of this.
160
161  unittest::TestAllTypes message;
162
163  EXPECT_DEATH(
164    ReflectionOps::Merge(message, &message),
165    "&from");
166}
167
168#endif  // GTEST_HAS_DEATH_TEST
169
170TEST(ReflectionOpsTest, Clear) {
171  unittest::TestAllTypes message;
172
173  TestUtil::SetAllFields(&message);
174
175  ReflectionOps::Clear(&message);
176
177  TestUtil::ExpectClear(message);
178
179  // Check that getting embedded messages returns the objects created during
180  // SetAllFields() rather than default instances.
181  EXPECT_NE(&unittest::TestAllTypes::OptionalGroup::default_instance(),
182            &message.optionalgroup());
183  EXPECT_NE(&unittest::TestAllTypes::NestedMessage::default_instance(),
184            &message.optional_nested_message());
185  EXPECT_NE(&unittest::ForeignMessage::default_instance(),
186            &message.optional_foreign_message());
187  EXPECT_NE(&unittest_import::ImportMessage::default_instance(),
188            &message.optional_import_message());
189}
190
191TEST(ReflectionOpsTest, ClearExtensions) {
192  unittest::TestAllExtensions message;
193
194  TestUtil::SetAllExtensions(&message);
195
196  ReflectionOps::Clear(&message);
197
198  TestUtil::ExpectExtensionsClear(message);
199
200  // Check that getting embedded messages returns the objects created during
201  // SetAllExtensions() rather than default instances.
202  EXPECT_NE(&unittest::OptionalGroup_extension::default_instance(),
203            &message.GetExtension(unittest::optionalgroup_extension));
204  EXPECT_NE(&unittest::TestAllTypes::NestedMessage::default_instance(),
205            &message.GetExtension(unittest::optional_nested_message_extension));
206  EXPECT_NE(&unittest::ForeignMessage::default_instance(),
207            &message.GetExtension(
208              unittest::optional_foreign_message_extension));
209  EXPECT_NE(&unittest_import::ImportMessage::default_instance(),
210            &message.GetExtension(unittest::optional_import_message_extension));
211}
212
213TEST(ReflectionOpsTest, ClearUnknown) {
214  // Test that the message's UnknownFieldSet is correctly cleared.
215  unittest::TestEmptyMessage message;
216  message.mutable_unknown_fields()->AddVarint(1234, 1);
217
218  ReflectionOps::Clear(&message);
219
220  EXPECT_EQ(0, message.unknown_fields().field_count());
221}
222
223TEST(ReflectionOpsTest, DiscardUnknownFields) {
224  unittest::TestAllTypes message;
225  TestUtil::SetAllFields(&message);
226
227  // Set some unknown fields in message.
228  message.mutable_unknown_fields()
229        ->AddVarint(123456, 654321);
230  message.mutable_optional_nested_message()
231        ->mutable_unknown_fields()
232        ->AddVarint(123456, 654321);
233  message.mutable_repeated_nested_message(0)
234        ->mutable_unknown_fields()
235        ->AddVarint(123456, 654321);
236
237  EXPECT_EQ(1, message.unknown_fields().field_count());
238  EXPECT_EQ(1, message.optional_nested_message()
239                      .unknown_fields().field_count());
240  EXPECT_EQ(1, message.repeated_nested_message(0)
241                      .unknown_fields().field_count());
242
243  // Discard them.
244  ReflectionOps::DiscardUnknownFields(&message);
245  TestUtil::ExpectAllFieldsSet(message);
246
247  EXPECT_EQ(0, message.unknown_fields().field_count());
248  EXPECT_EQ(0, message.optional_nested_message()
249                      .unknown_fields().field_count());
250  EXPECT_EQ(0, message.repeated_nested_message(0)
251                      .unknown_fields().field_count());
252}
253
254TEST(ReflectionOpsTest, DiscardUnknownExtensions) {
255  unittest::TestAllExtensions message;
256  TestUtil::SetAllExtensions(&message);
257
258  // Set some unknown fields.
259  message.mutable_unknown_fields()
260        ->AddVarint(123456, 654321);
261  message.MutableExtension(unittest::optional_nested_message_extension)
262        ->mutable_unknown_fields()
263        ->AddVarint(123456, 654321);
264  message.MutableExtension(unittest::repeated_nested_message_extension, 0)
265        ->mutable_unknown_fields()
266        ->AddVarint(123456, 654321);
267
268  EXPECT_EQ(1, message.unknown_fields().field_count());
269  EXPECT_EQ(1,
270    message.GetExtension(unittest::optional_nested_message_extension)
271           .unknown_fields().field_count());
272  EXPECT_EQ(1,
273    message.GetExtension(unittest::repeated_nested_message_extension, 0)
274           .unknown_fields().field_count());
275
276  // Discard them.
277  ReflectionOps::DiscardUnknownFields(&message);
278  TestUtil::ExpectAllExtensionsSet(message);
279
280  EXPECT_EQ(0, message.unknown_fields().field_count());
281  EXPECT_EQ(0,
282    message.GetExtension(unittest::optional_nested_message_extension)
283           .unknown_fields().field_count());
284  EXPECT_EQ(0,
285    message.GetExtension(unittest::repeated_nested_message_extension, 0)
286           .unknown_fields().field_count());
287}
288
289TEST(ReflectionOpsTest, IsInitialized) {
290  unittest::TestRequired message;
291
292  EXPECT_FALSE(ReflectionOps::IsInitialized(message));
293  message.set_a(1);
294  EXPECT_FALSE(ReflectionOps::IsInitialized(message));
295  message.set_b(2);
296  EXPECT_FALSE(ReflectionOps::IsInitialized(message));
297  message.set_c(3);
298  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
299}
300
301TEST(ReflectionOpsTest, ForeignIsInitialized) {
302  unittest::TestRequiredForeign message;
303
304  // Starts out initialized because the foreign message is itself an optional
305  // field.
306  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
307
308  // Once we create that field, the message is no longer initialized.
309  message.mutable_optional_message();
310  EXPECT_FALSE(ReflectionOps::IsInitialized(message));
311
312  // Initialize it.  Now we're initialized.
313  message.mutable_optional_message()->set_a(1);
314  message.mutable_optional_message()->set_b(2);
315  message.mutable_optional_message()->set_c(3);
316  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
317
318  // Add a repeated version of the message.  No longer initialized.
319  unittest::TestRequired* sub_message = message.add_repeated_message();
320  EXPECT_FALSE(ReflectionOps::IsInitialized(message));
321
322  // Initialize that repeated version.
323  sub_message->set_a(1);
324  sub_message->set_b(2);
325  sub_message->set_c(3);
326  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
327}
328
329TEST(ReflectionOpsTest, ExtensionIsInitialized) {
330  unittest::TestAllExtensions message;
331
332  // Starts out initialized because the foreign message is itself an optional
333  // field.
334  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
335
336  // Once we create that field, the message is no longer initialized.
337  message.MutableExtension(unittest::TestRequired::single);
338  EXPECT_FALSE(ReflectionOps::IsInitialized(message));
339
340  // Initialize it.  Now we're initialized.
341  message.MutableExtension(unittest::TestRequired::single)->set_a(1);
342  message.MutableExtension(unittest::TestRequired::single)->set_b(2);
343  message.MutableExtension(unittest::TestRequired::single)->set_c(3);
344  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
345
346  // Add a repeated version of the message.  No longer initialized.
347  message.AddExtension(unittest::TestRequired::multi);
348  EXPECT_FALSE(ReflectionOps::IsInitialized(message));
349
350  // Initialize that repeated version.
351  message.MutableExtension(unittest::TestRequired::multi, 0)->set_a(1);
352  message.MutableExtension(unittest::TestRequired::multi, 0)->set_b(2);
353  message.MutableExtension(unittest::TestRequired::multi, 0)->set_c(3);
354  EXPECT_TRUE(ReflectionOps::IsInitialized(message));
355}
356
357static string FindInitializationErrors(const Message& message) {
358  vector<string> errors;
359  ReflectionOps::FindInitializationErrors(message, "", &errors);
360  return JoinStrings(errors, ",");
361}
362
363TEST(ReflectionOpsTest, FindInitializationErrors) {
364  unittest::TestRequired message;
365  EXPECT_EQ("a,b,c", FindInitializationErrors(message));
366}
367
368TEST(ReflectionOpsTest, FindForeignInitializationErrors) {
369  unittest::TestRequiredForeign message;
370  message.mutable_optional_message();
371  message.add_repeated_message();
372  message.add_repeated_message();
373  EXPECT_EQ("optional_message.a,"
374            "optional_message.b,"
375            "optional_message.c,"
376            "repeated_message[0].a,"
377            "repeated_message[0].b,"
378            "repeated_message[0].c,"
379            "repeated_message[1].a,"
380            "repeated_message[1].b,"
381            "repeated_message[1].c",
382            FindInitializationErrors(message));
383}
384
385TEST(ReflectionOpsTest, FindExtensionInitializationErrors) {
386  unittest::TestAllExtensions message;
387  message.MutableExtension(unittest::TestRequired::single);
388  message.AddExtension(unittest::TestRequired::multi);
389  message.AddExtension(unittest::TestRequired::multi);
390  EXPECT_EQ("(protobuf_unittest.TestRequired.single).a,"
391            "(protobuf_unittest.TestRequired.single).b,"
392            "(protobuf_unittest.TestRequired.single).c,"
393            "(protobuf_unittest.TestRequired.multi)[0].a,"
394            "(protobuf_unittest.TestRequired.multi)[0].b,"
395            "(protobuf_unittest.TestRequired.multi)[0].c,"
396            "(protobuf_unittest.TestRequired.multi)[1].a,"
397            "(protobuf_unittest.TestRequired.multi)[1].b,"
398            "(protobuf_unittest.TestRequired.multi)[1].c",
399            FindInitializationErrors(message));
400}
401
402}  // namespace
403}  // namespace internal
404}  // namespace protobuf
405}  // namespace google