third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/extension_set_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 187 matching lines @@
       unittest::TestMessageSetExtension1::message_set_extension,
       extension);
   message.ClearExtension(
       unittest::TestMessageSetExtension1::message_set_extension);
   released_extension = message.ReleaseExtension(
       unittest::TestMessageSetExtension1::message_set_extension);
   EXPECT_TRUE(released_extension != NULL);
   delete released_extension;
 }
 
+TEST(ExtensionSetTest, ArenaUnsafeArenaSetAllocatedAndRelease) {
+  ::google::protobuf::Arena arena;
+  unittest::TestAllExtensions* message =
+      ::google::protobuf::Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
+  unittest::ForeignMessage extension;
+  message->UnsafeArenaSetAllocatedExtension(
+      unittest::optional_foreign_message_extension,
+      &extension);
+  // No copy when set.
+  unittest::ForeignMessage* mutable_extension =
+      message->MutableExtension(unittest::optional_foreign_message_extension);
+  EXPECT_EQ(&extension, mutable_extension);
+  // No copy when unsafe released.
+  unittest::ForeignMessage* released_extension =
+      message->UnsafeArenaReleaseExtension(
+          unittest::optional_foreign_message_extension);
+  EXPECT_EQ(&extension, released_extension);
+  EXPECT_FALSE(message->HasExtension(
+      unittest::optional_foreign_message_extension));
+  // Set the ownership back and let the destructors run.  It should not take
+  // ownership, so this should not crash.
+  message->UnsafeArenaSetAllocatedExtension(
+      unittest::optional_foreign_message_extension,
+      &extension);
+}
+
+TEST(ExtensionSetTest, UnsafeArenaSetAllocatedAndRelease) {
+  unittest::TestAllExtensions message;
+  unittest::ForeignMessage* extension = new unittest::ForeignMessage();
+  message.UnsafeArenaSetAllocatedExtension(
+      unittest::optional_foreign_message_extension,
+      extension);
+  // No copy when set.
+  unittest::ForeignMessage* mutable_extension =
+      message.MutableExtension(unittest::optional_foreign_message_extension);
+  EXPECT_EQ(extension, mutable_extension);
+  // No copy when unsafe released.
+  unittest::ForeignMessage* released_extension =
+      message.UnsafeArenaReleaseExtension(
+          unittest::optional_foreign_message_extension);
+  EXPECT_EQ(extension, released_extension);
+  EXPECT_FALSE(message.HasExtension(
+      unittest::optional_foreign_message_extension));
+  // Set the ownership back and let the destructors run.  It should take
+  // ownership, so this should not leak.
+  message.UnsafeArenaSetAllocatedExtension(
+      unittest::optional_foreign_message_extension,
+      extension);
+}
+
+TEST(ExtensionSetTest, ArenaUnsafeArenaReleaseOfHeapAlloc) {
+  ::google::protobuf::Arena arena;
+  unittest::TestAllExtensions* message =
+      ::google::protobuf::Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
+  unittest::ForeignMessage* extension = new unittest::ForeignMessage;
+  message->SetAllocatedExtension(
+      unittest::optional_foreign_message_extension,
+      extension);
+  // The arena should maintain ownership of the heap allocated proto because we
+  // used UnsafeArenaReleaseExtension.  The leak checker will ensure this.
+  unittest::ForeignMessage* released_extension =
+      message->UnsafeArenaReleaseExtension(
+          unittest::optional_foreign_message_extension);
+  EXPECT_EQ(extension, released_extension);
+  EXPECT_FALSE(message->HasExtension(
+      unittest::optional_foreign_message_extension));
+}
+
 
 TEST(ExtensionSetTest, CopyFrom) {
   unittest::TestAllExtensions message1, message2;
 
   TestUtil::SetAllExtensions(&message1);
   message2.CopyFrom(message1);
   TestUtil::ExpectAllExtensionsSet(message2);
   message2.CopyFrom(message1);  // exercise copy when fields already exist
   TestUtil::ExpectAllExtensionsSet(message2);
 }
@@ skipping 38 matching lines @@
   TestUtil::ExpectAllExtensionsSet(message);
   message.Swap(&message);
   TestUtil::ExpectAllExtensionsSet(message);
 }
 
 TEST(ExtensionSetTest, SwapExtension) {
   unittest::TestAllExtensions message1;
   unittest::TestAllExtensions message2;
 
   TestUtil::SetAllExtensions(&message1);
-  vector<const FieldDescriptor*> fields;
+  std::vector<const FieldDescriptor*> fields;
 
   // Swap empty fields.
   const Reflection* reflection = message1.GetReflection();
   reflection->SwapFields(&message1, &message2, fields);
   TestUtil::ExpectAllExtensionsSet(message1);
   TestUtil::ExpectExtensionsClear(message2);
 
   // Swap two extensions.
   fields.push_back(
       reflection->FindKnownExtensionByNumber(12));
@@ skipping 11 matching lines @@
 }
 
 TEST(ExtensionSetTest, SwapExtensionWithEmpty) {
   unittest::TestAllExtensions message1;
   unittest::TestAllExtensions message2;
   unittest::TestAllExtensions message3;
 
   TestUtil::SetAllExtensions(&message3);
 
   const Reflection* reflection = message3.GetReflection();
-  vector<const FieldDescriptor*> fields;
+  std::vector<const FieldDescriptor*> fields;
   reflection->ListFields(message3, &fields);
 
   reflection->SwapFields(&message1, &message2, fields);
 
   TestUtil::ExpectExtensionsClear(message1);
   TestUtil::ExpectExtensionsClear(message2);
 }
 
 TEST(ExtensionSetTest, SwapExtensionBothFull) {
   unittest::TestAllExtensions message1;
   unittest::TestAllExtensions message2;
 
   TestUtil::SetAllExtensions(&message1);
   TestUtil::SetAllExtensions(&message2);
 
   const Reflection* reflection = message1.GetReflection();
-  vector<const FieldDescriptor*> fields;
+  std::vector<const FieldDescriptor*> fields;
   reflection->ListFields(message1, &fields);
 
   reflection->SwapFields(&message1, &message2, fields);
 
   TestUtil::ExpectAllExtensionsSet(message1);
   TestUtil::ExpectAllExtensionsSet(message2);
 }
 
 TEST(ExtensionSetTest, ArenaSetAllExtension) {
   ::google::protobuf::Arena arena1;
@@ skipping 89 matching lines @@
 
   unittest::TestAllExtensions* message1 =
       Arena::CreateMessage<unittest::TestAllExtensions>(&arena1);
   unittest::TestAllExtensions* message2 =
       Arena::CreateMessage<unittest::TestAllExtensions>(arena2);
 
   TestUtil::SetAllExtensions(message1);
   TestUtil::SetAllExtensions(message2);
 
   const Reflection* reflection = message1->GetReflection();
-  vector<const FieldDescriptor*> fields;
+  std::vector<const FieldDescriptor*> fields;
   reflection->ListFields(*message1, &fields);
   reflection->SwapFields(message1, message2, fields);
   TestUtil::ExpectAllExtensionsSet(*message1);
   TestUtil::ExpectAllExtensionsSet(*message2);
   delete arena2;
   TestUtil::ExpectAllExtensionsSet(*message1);
 }
 
 TEST(ExtensionSetTest, SwapExtensionWithSelf) {
   unittest::TestAllExtensions message1;
 
   TestUtil::SetAllExtensions(&message1);
 
-  vector<const FieldDescriptor*> fields;
+  std::vector<const FieldDescriptor*> fields;
   const Reflection* reflection = message1.GetReflection();
   reflection->ListFields(message1, &fields);
   reflection->SwapFields(&message1, &message1, fields);
 
   TestUtil::ExpectAllExtensionsSet(message1);
 }
 
 TEST(ExtensionSetTest, SerializationToArray) {
   // Serialize as TestAllExtensions and parse as TestAllTypes to insure wire
   // compatibility of extensions.
@@ skipping 271 matching lines @@
     EXPECT_LE(min_expected_size, empty_repeated_field_size) << #type;          \
     message.AddExtension(unittest::repeated_##type##_extension, value);        \
     message.AddExtension(unittest::repeated_##type##_extension, value);        \
     EXPECT_EQ(empty_repeated_field_size, message.SpaceUsed()) << #type;        \
     message.ClearExtension(unittest::repeated_##type##_extension);             \
     for (int i = 0; i < 16; ++i) {                                             \
       message.AddExtension(unittest::repeated_##type##_extension, value);      \
     }                                                                          \
     int expected_size = sizeof(cpptype) * (16 -                                \
         kMinRepeatedFieldAllocationSize) + empty_repeated_field_size;          \
-    EXPECT_EQ(expected_size, message.SpaceUsed()) << #type;                    \
+    EXPECT_LE(expected_size, message.SpaceUsed()) << #type;                    \
   } while (0)
 
   TEST_REPEATED_EXTENSIONS_SPACE_USED(int32   , int32 , 101);
   TEST_REPEATED_EXTENSIONS_SPACE_USED(int64   , int64 , 102);
   TEST_REPEATED_EXTENSIONS_SPACE_USED(uint32  , uint32, 103);
   TEST_REPEATED_EXTENSIONS_SPACE_USED(uint64  , uint64, 104);
   TEST_REPEATED_EXTENSIONS_SPACE_USED(sint32  , int32 , 105);
   TEST_REPEATED_EXTENSIONS_SPACE_USED(sint64  , int64 , 106);
   TEST_REPEATED_EXTENSIONS_SPACE_USED(fixed32 , uint32, 107);
   TEST_REPEATED_EXTENSIONS_SPACE_USED(fixed64 , uint64, 108);
@@ skipping 456 matching lines @@
     const Message* prototype =
         dynamic_factory.GetPrototype(dynamic_message_extension->message_type());
     EXPECT_EQ(prototype, &sub_message);
   }
 }
 
 }  // namespace
 }  // namespace internal
 }  // namespace protobuf
 }  // namespace google