third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/arena_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 24 matching lines @@
 #include <memory>
 #ifndef _SHARED_PTR_H
 #include <google/protobuf/stubs/shared_ptr.h>
 #endif
 #include <string>
 #include <typeinfo>
 #include <vector>
 
 #include <google/protobuf/stubs/logging.h>
 #include <google/protobuf/stubs/common.h>
-#include <google/protobuf/stubs/scoped_ptr.h>
 #include <google/protobuf/arena_test_util.h>
 #include <google/protobuf/test_util.h>
 #include <google/protobuf/unittest.pb.h>
 #include <google/protobuf/unittest_arena.pb.h>
 #include <google/protobuf/unittest_no_arena.pb.h>
 #include <google/protobuf/io/coded_stream.h>
 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/extension_set.h>
 #include <google/protobuf/message.h>
@@ skipping 89 matching lines @@
   const PleaseDontCopyMe* four_;
   int five_;
   const char* const six_;
   string seven_;
   string eight_;
 
  private:
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MustBeConstructedWithOneThroughEight);
 };
 
-}  // namespace
-
 TEST(ArenaTest, ArenaConstructable) {
   EXPECT_TRUE(Arena::is_arena_constructable<TestAllTypes>::type::value);
   EXPECT_TRUE(Arena::is_arena_constructable<const TestAllTypes>::type::value);
   EXPECT_FALSE(Arena::is_arena_constructable<Arena>::type::value);
 }
 
 TEST(ArenaTest, BasicCreate) {
   Arena arena;
   EXPECT_TRUE(Arena::Create<int32>(&arena) != NULL);
   EXPECT_TRUE(Arena::Create<int64>(&arena) != NULL);
@@ skipping 78 matching lines @@
 TEST(ArenaTest, Parsing) {
   TestAllTypes original;
   TestUtil::SetAllFields(&original);
 
   // Test memory leak.
   Arena arena;
   TestAllTypes* arena_message = Arena::CreateMessage<TestAllTypes>(&arena);
   arena_message->ParseFromString(original.SerializeAsString());
   TestUtil::ExpectAllFieldsSet(*arena_message);
 
-  // Test that string fields have null terminator bytes (earlier bug).
+  // Test that string fields have nul terminator bytes (earlier bug).
   EXPECT_EQ(strlen(original.optional_string().c_str()),
             strlen(arena_message->optional_string().c_str()));
 }
 
 TEST(ArenaTest, UnknownFields) {
   TestAllTypes original;
   TestUtil::SetAllFields(&original);
 
   // Test basic parsing into (populating) and reading out of unknown fields on
   // an arena.
@@ skipping 621 matching lines @@
 
   s = new string("test string");
   message->unsafe_arena_set_allocated_oneof_string(s);
   EXPECT_TRUE(message->has_oneof_string());
   EXPECT_EQ("test string", message->oneof_string());
   s = message->unsafe_arena_release_oneof_string();
   EXPECT_FALSE(message->has_oneof_string());
   delete s;
 }
 
+TEST(ArenaTest, OneofMerge) {
+  Arena arena;
+  TestAllTypes* message0 = Arena::CreateMessage<TestAllTypes>(&arena);
+  TestAllTypes* message1 = Arena::CreateMessage<TestAllTypes>(&arena);
+
+  message0->unsafe_arena_set_allocated_oneof_string(new string("x"));
+  ASSERT_TRUE(message0->has_oneof_string());
+  message1->unsafe_arena_set_allocated_oneof_string(new string("y"));
+  ASSERT_TRUE(message1->has_oneof_string());
+  EXPECT_EQ("x", message0->oneof_string());
+  EXPECT_EQ("y", message1->oneof_string());
+  message0->MergeFrom(*message1);
+  EXPECT_EQ("y", message0->oneof_string());
+  EXPECT_EQ("y", message1->oneof_string());
+  delete message0->unsafe_arena_release_oneof_string();
+  delete message1->unsafe_arena_release_oneof_string();
+}
+
 TEST(ArenaTest, ArenaOneofReflection) {
   Arena arena;
   TestAllTypes* message = Arena::CreateMessage<TestAllTypes>(&arena);
   const Descriptor* desc = message->GetDescriptor();
   const Reflection* refl = message->GetReflection();
 
   const FieldDescriptor* string_field = desc->FindFieldByName(
       "oneof_string");
   const FieldDescriptor* msg_field = desc->FindFieldByName(
       "oneof_nested_message");
@@ skipping 10 matching lines @@
   refl->ClearOneof(message, oneof);
   EXPECT_FALSE(refl->HasOneof(*message, oneof));
   refl->MutableMessage(message, msg_field);
   EXPECT_TRUE(refl->HasOneof(*message, oneof));
   submsg = refl->ReleaseMessage(message, msg_field);
   EXPECT_FALSE(refl->HasOneof(*message, oneof));
   EXPECT_TRUE(submsg->GetArena() == NULL);
   delete submsg;
 }
 
-namespace {
 void TestSwapRepeatedField(Arena* arena1, Arena* arena2) {
   // Test "safe" (copying) semantics for direct Swap() on RepeatedPtrField
   // between arenas.
   RepeatedPtrField<TestAllTypes> field1(arena1);
   RepeatedPtrField<TestAllTypes> field2(arena2);
   for (int i = 0; i < 10; i++) {
     TestAllTypes* t = Arena::CreateMessage<TestAllTypes>(arena1);
     t->set_optional_string("field1");
     t->set_optional_int32(i);
     if (arena1 != NULL) {
@@ skipping 18 matching lines @@
   EXPECT_TRUE(string("field1") == field2.Get(0).optional_string());
   EXPECT_TRUE(string("field2") == field1.Get(0).optional_string());
   // Ensure that fields retained their original order:
   for (int i = 0; i < field1.size(); i++) {
     EXPECT_EQ(i, field1.Get(i).optional_int32());
   }
   for (int i = 0; i < field2.size(); i++) {
     EXPECT_EQ(i, field2.Get(i).optional_int32());
   }
 }
-}  // namespace
 
 TEST(ArenaTest, SwapRepeatedField) {
   Arena arena;
   TestSwapRepeatedField(&arena, &arena);
 }
 
 TEST(ArenaTest, SwapRepeatedFieldWithDifferentArenas) {
   Arena arena1;
   Arena arena2;
   TestSwapRepeatedField(&arena1, &arena2);
@@ skipping 121 matching lines @@
   submessage = static_cast<TestAllTypes::NestedMessage*>(
       r->MutableMessage(message, oneof_field));
   submessage_expected = message->mutable_oneof_nested_message();
 
   EXPECT_EQ(submessage_expected, submessage);
   EXPECT_EQ(&arena, submessage->GetArena());
 }
 #endif  // !GOOGLE_PROTOBUF_NO_RTTI
 
 
-namespace {
-
 void FillArenaAwareFields(TestAllTypes* message) {
   string test_string = "hello world";
   message->set_optional_int32(42);
   message->set_optional_string(test_string);
   message->set_optional_bytes(test_string);
   message->mutable_optional_nested_message()->set_bb(42);
 
   message->set_oneof_uint32(42);
   message->mutable_oneof_nested_message()->set_bb(42);
   message->set_oneof_string(test_string);
   message->set_oneof_bytes(test_string);
 
   message->add_repeated_int32(42);
   // No repeated string: not yet arena-aware.
   message->add_repeated_nested_message()->set_bb(42);
   message->mutable_optional_lazy_message()->set_bb(42);
 }
 
-}
-
 // Test: no allocations occur on heap while touching all supported field types.
 TEST(ArenaTest, NoHeapAllocationsTest) {
   // Allocate a large initial block to avoid mallocs during hooked test.
   std::vector<char> arena_block(128 * 1024);
   ArenaOptions options;
   options.initial_block = &arena_block[0];
   options.initial_block_size = arena_block.size();
   Arena arena(options);
 
   {
 
     TestAllTypes* message = Arena::CreateMessage<TestAllTypes>(&arena);
     FillArenaAwareFields(message);
   }
 
   arena.Reset();
 }
 
+TEST(ArenaTest, ParseCorruptedString) {
+  TestAllTypes message;
+  TestUtil::SetAllFields(&message);
+  TestParseCorruptedString<TestAllTypes, true>(message);
+  TestParseCorruptedString<TestAllTypes, false>(message);
+}
+
 #ifndef GOOGLE_PROTOBUF_NO_RTTI
 // Test construction on an arena via generic MessageLite interface. We should be
 // able to successfully deserialize on the arena without incurring heap
 // allocations, i.e., everything should still be arena-allocation-aware.
 TEST(ArenaTest, MessageLiteOnArena) {
   std::vector<char> arena_block(128 * 1024);
   ArenaOptions options;
   options.initial_block = &arena_block[0];
   options.initial_block_size = arena_block.size();
   Arena arena(options);
@@ skipping 32 matching lines @@
   {
     Arena arena;
     RepeatedField<string> field_on_arena(&arena);
     for (int i = 0; i < 100; i++) {
       *field_on_arena.Add() = "test string long enough to exceed inline buffer";
     }
   }
 }
 
 // Align n to next multiple of 8
-namespace {
 uint64 Align8(uint64 n) { return (n + 7) & -8; }
-}  // namespace
 
 TEST(ArenaTest, SpaceAllocated_and_Used) {
   ArenaOptions options;
   options.start_block_size = 256;
   options.max_block_size = 8192;
   Arena arena_1(options);
   EXPECT_EQ(0, arena_1.SpaceAllocated());
   EXPECT_EQ(0, arena_1.SpaceUsed());
   EXPECT_EQ(0, arena_1.Reset());
   ::google::protobuf::Arena::CreateArray<char>(&arena_1, 320);
@@ skipping 30 matching lines @@
 }
 
 TEST(ArenaTest, Alignment) {
   ::google::protobuf::Arena arena;
   for (int i = 0; i < 200; i++) {
     void* p = ::google::protobuf::Arena::CreateArray<char>(&arena, i);
     GOOGLE_CHECK_EQ(reinterpret_cast<uintptr_t>(p) % 8, 0) << i << ": " << p;
   }
 }
 
+TEST(ArenaTest, BlockSizeSmallerThanAllocation) {
+  for (size_t i = 0; i <= 8; ++i) {
+    ::google::protobuf::ArenaOptions opt;
+    opt.start_block_size = opt.max_block_size = i;
+    ::google::protobuf::Arena arena(opt);
+
+    *::google::protobuf::Arena::Create<int64>(&arena) = 42;
+    EXPECT_GE(arena.SpaceAllocated(), 8);
+    EXPECT_EQ(8, arena.SpaceUsed());
+
+    *::google::protobuf::Arena::Create<int64>(&arena) = 42;
+    EXPECT_GE(arena.SpaceAllocated(), 16);
+    EXPECT_EQ(16, arena.SpaceUsed());
+  }
+}
+
 TEST(ArenaTest, GetArenaShouldReturnTheArenaForArenaAllocatedMessages) {
   ::google::protobuf::Arena arena;
   ArenaMessage* message = Arena::CreateMessage<ArenaMessage>(&arena);
   const ArenaMessage* const_pointer_to_message = message;
   EXPECT_EQ(&arena, Arena::GetArena(message));
   EXPECT_EQ(&arena, Arena::GetArena(const_pointer_to_message));
 }
 
 TEST(ArenaTest, GetArenaShouldReturnNullForNonArenaAllocatedMessages) {
   ArenaMessage message;
@@ skipping 80 matching lines @@
       EXPECT_EQ(2, ArenaHooksTestUtil::num_allocations);
     }
     arena.Reset();
     arena.Reset();
     EXPECT_EQ(2, ArenaHooksTestUtil::num_reset);
   }
   EXPECT_EQ(3, ArenaHooksTestUtil::num_reset);
   EXPECT_EQ(1, ArenaHooksTestUtil::num_destruct);
 }
 
+
+}  // namespace
 }  // namespace protobuf
 }  // namespace google