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

http://github.com/tomahawk-player/tomahawk · C++ · 405 lines · 257 code · 81 blank · 67 comment · 0 complexity · 2616136767baec9aecf968ce078c7f22 MD5 · raw file

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