third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/generated_message_reflection_unittest.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 204 matching lines @@
 
 TEST(GeneratedMessageReflectionTest, SwapFields) {
   unittest::TestAllTypes message1, message2;
   message1.set_optional_double(12.3);
   message1.mutable_repeated_int32()->Add(10);
   message1.mutable_repeated_int32()->Add(20);
 
   message2.set_optional_string("hello");
   message2.mutable_repeated_int64()->Add(30);
 
-  vector<const FieldDescriptor*> fields;
+  std::vector<const FieldDescriptor*> fields;
   const Descriptor* descriptor = message1.GetDescriptor();
   fields.push_back(descriptor->FindFieldByName("optional_double"));
   fields.push_back(descriptor->FindFieldByName("repeated_int32"));
   fields.push_back(descriptor->FindFieldByName("optional_string"));
   fields.push_back(descriptor->FindFieldByName("optional_uint64"));
 
   const Reflection* reflection = message1.GetReflection();
   reflection->SwapFields(&message1, &message2, fields);
 
   EXPECT_FALSE(message1.has_optional_double());
@@ skipping 12 matching lines @@
   EXPECT_EQ(1, message2.repeated_int64_size());
   EXPECT_FALSE(message2.has_optional_uint64());
 }
 
 TEST(GeneratedMessageReflectionTest, SwapFieldsAll) {
   unittest::TestAllTypes message1;
   unittest::TestAllTypes message2;
 
   TestUtil::SetAllFields(&message2);
 
-  vector<const FieldDescriptor*> fields;
+  std::vector<const FieldDescriptor*> fields;
   const Reflection* reflection = message1.GetReflection();
   reflection->ListFields(message2, &fields);
   reflection->SwapFields(&message1, &message2, fields);
 
   TestUtil::ExpectAllFieldsSet(message1);
   TestUtil::ExpectClear(message2);
 }
 
 TEST(GeneratedMessageReflectionTest, SwapFieldsAllExtension) {
   unittest::TestAllExtensions message1;
   unittest::TestAllExtensions message2;
 
   TestUtil::SetAllExtensions(&message1);
 
-  vector<const FieldDescriptor*> fields;
+  std::vector<const FieldDescriptor*> fields;
   const Reflection* reflection = message1.GetReflection();
   reflection->ListFields(message1, &fields);
   reflection->SwapFields(&message1, &message2, fields);
 
   TestUtil::ExpectExtensionsClear(message1);
   TestUtil::ExpectAllExtensionsSet(message2);
 }
 
 TEST(GeneratedMessageReflectionTest, SwapOneof) {
   unittest::TestOneof2 message1, message2;
@@ skipping 15 matching lines @@
   reflection->Swap(&message1, &message2);
 
   TestUtil::ExpectOneofSet2(message1);
   TestUtil::ExpectOneofSet1(message2);
 }
 
 TEST(GeneratedMessageReflectionTest, SwapFieldsOneof) {
   unittest::TestOneof2 message1, message2;
   TestUtil::SetOneof1(&message1);
 
-  vector<const FieldDescriptor*> fields;
+  std::vector<const FieldDescriptor*> fields;
   const Descriptor* descriptor = message1.GetDescriptor();
   for (int i = 0; i < descriptor->field_count(); i++) {
     fields.push_back(descriptor->field(i));
   }
   const Reflection* reflection = message1.GetReflection();
   reflection->SwapFields(&message1, &message2, fields);
 
   TestUtil::ExpectOneofClear(message1);
   TestUtil::ExpectOneofSet1(message2);
 }
@@ skipping 281 matching lines @@
   reflection->AddAllocatedMessage(&message, F("repeated_nested_message"), nested);
   EXPECT_EQ(1, message.repeated_nested_message_size());
   EXPECT_EQ(11, message.repeated_nested_message(0).bb());
 }
 
 TEST(GeneratedMessageReflectionTest, ListFieldsOneOf) {
   unittest::TestOneof2 message;
   TestUtil::SetOneof1(&message);
 
   const Reflection* reflection = message.GetReflection();
-  vector<const FieldDescriptor*> fields;
+  std::vector<const FieldDescriptor*> fields;
   reflection->ListFields(message, &fields);
   EXPECT_EQ(4, fields.size());
 }
 
 TEST(GeneratedMessageReflectionTest, Oneof) {
   unittest::TestOneof2 message;
   const Descriptor* descriptor = message.GetDescriptor();
   const Reflection* reflection = message.GetReflection();
 
   // Check default values.
@@ skipping 166 matching lines @@
 
   EXPECT_TRUE(released != NULL);
   EXPECT_EQ(&sub_message, released);
   delete released;
 
   released = reflection->ReleaseMessage(
       &message, descriptor->FindFieldByName("foo_lazy_message"));
   EXPECT_TRUE(released == NULL);
 }
 
+TEST(GeneratedMessageReflectionTest, ArenaReleaseMessageTest) {
+  ::google::protobuf::Arena arena;
+  unittest::TestAllTypes* message =
+      ::google::protobuf::Arena::CreateMessage<unittest::TestAllTypes>(&arena);
+  TestUtil::ReflectionTester reflection_tester(
+      unittest::TestAllTypes::descriptor());
+
+  // When nothing is set, we expect all released messages to be NULL.
+  reflection_tester.ExpectMessagesReleasedViaReflection(
+      message, TestUtil::ReflectionTester::IS_NULL);
+
+  // After fields are set we should get non-NULL releases.
+  reflection_tester.SetAllFieldsViaReflection(message);
+  reflection_tester.ExpectMessagesReleasedViaReflection(
+      message, TestUtil::ReflectionTester::NOT_NULL);
+
+  // After Clear() we may or may not get a message from ReleaseMessage().
+  // This is implementation specific.
+  reflection_tester.SetAllFieldsViaReflection(message);
+  message->Clear();
+  reflection_tester.ExpectMessagesReleasedViaReflection(
+      message, TestUtil::ReflectionTester::CAN_BE_NULL);
+}
+
+TEST(GeneratedMessageReflectionTest, ArenaReleaseExtensionMessageTest) {
+  ::google::protobuf::Arena arena;
+  unittest::TestAllExtensions* message =
+      ::google::protobuf::Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
+  TestUtil::ReflectionTester reflection_tester(
+      unittest::TestAllExtensions::descriptor());
+
+  // When nothing is set, we expect all released messages to be NULL.
+  reflection_tester.ExpectMessagesReleasedViaReflection(
+      message, TestUtil::ReflectionTester::IS_NULL);
+
+  // After fields are set we should get non-NULL releases.
+  reflection_tester.SetAllFieldsViaReflection(message);
+  reflection_tester.ExpectMessagesReleasedViaReflection(
+      message, TestUtil::ReflectionTester::NOT_NULL);
+
+  // After Clear() we may or may not get a message from ReleaseMessage().
+  // This is implementation specific.
+  reflection_tester.SetAllFieldsViaReflection(message);
+  message->Clear();
+  reflection_tester.ExpectMessagesReleasedViaReflection(
+      message, TestUtil::ReflectionTester::CAN_BE_NULL);
+}
+
+TEST(GeneratedMessageReflectionTest, ArenaReleaseOneofMessageTest) {
+  ::google::protobuf::Arena arena;
+  unittest::TestOneof2* message =
+      ::google::protobuf::Arena::CreateMessage<unittest::TestOneof2>(&arena);
+  TestUtil::ReflectionTester::SetOneofViaReflection(message);
+
+  const Descriptor* descriptor = unittest::TestOneof2::descriptor();
+  const Reflection* reflection = message->GetReflection();
+  Message* released = reflection->ReleaseMessage(
+      message, descriptor->FindFieldByName("foo_lazy_message"));
+
+  EXPECT_TRUE(released != NULL);
+  delete released;
+
+  released = reflection->ReleaseMessage(
+      message, descriptor->FindFieldByName("foo_lazy_message"));
+  EXPECT_TRUE(released == NULL);
+}
+
 #ifdef PROTOBUF_HAS_DEATH_TEST
 
 TEST(GeneratedMessageReflectionTest, UsageErrors) {
   unittest::TestAllTypes message;
   const Reflection* reflection = message.GetReflection();
   const Descriptor* descriptor = message.GetDescriptor();
 
 #define f(NAME) descriptor->FindFieldByName(NAME)
 
   // Testing every single failure mode would be too much work.  Let's just
@@ skipping 35 matching lines @@
 
 #undef f
 }
 
 #endif  // PROTOBUF_HAS_DEATH_TEST
 
 
 }  // namespace
 }  // namespace protobuf
 }  // namespace google