Reverts third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/src/google/protobuf/compiler/cpp/cpp_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 35 matching lines @@
 
 #include <google/protobuf/compiler/cpp/cpp_unittest.h>
 
 #include <memory>
 #ifndef _SHARED_PTR_H
 #include <google/protobuf/stubs/shared_ptr.h>
 #endif
 #include <vector>
 
 #include <google/protobuf/unittest.pb.h>
-#include <google/protobuf/unittest_no_arena.pb.h>
 #include <google/protobuf/unittest_optimize_for.pb.h>
 #include <google/protobuf/unittest_embed_optimize_for.pb.h>
 #if !defined(GOOGLE_PROTOBUF_CMAKE_BUILD) && !defined(_MSC_VER)
 // We exclude this large proto from cmake build because it's too large for
 // visual studio to compile (report internal errors).
 #include <google/protobuf/unittest_enormous_descriptor.pb.h>
 #endif
 #include <google/protobuf/unittest_no_generic_services.pb.h>
 #include <google/protobuf/test_util.h>
 #include <google/protobuf/compiler/cpp/cpp_helpers.h>
 #include <google/protobuf/compiler/cpp/cpp_test_bad_identifiers.pb.h>
 #include <google/protobuf/compiler/importer.h>
 #include <google/protobuf/io/coded_stream.h>
 #include <google/protobuf/io/zero_copy_stream_impl.h>
-#include <google/protobuf/arena.h>
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/descriptor.pb.h>
 #include <google/protobuf/dynamic_message.h>
 
 #include <google/protobuf/stubs/callback.h>
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/stubs/logging.h>
 #include <google/protobuf/stubs/strutil.h>
 #include <google/protobuf/stubs/substitute.h>
 #include <google/protobuf/testing/googletest.h>
@@ skipping 42 matching lines @@
   Importer importer(&source_tree, &error_collector);
 
   // Import (parse) unittest.proto.
   const FileDescriptor* parsed_descriptor =
     importer.Import("google/protobuf/unittest.proto");
   EXPECT_EQ("", error_collector.text_);
   ASSERT_TRUE(parsed_descriptor != NULL);
 
   // Test that descriptors are generated correctly by converting them to
   // FileDescriptorProtos and comparing.
-  FileDescriptorProto generated_descriptor_proto, parsed_descriptor_proto;
-  generated_descriptor->CopyTo(&generated_descriptor_proto);
+  FileDescriptorProto generated_decsriptor_proto, parsed_descriptor_proto;
+  generated_descriptor->CopyTo(&generated_decsriptor_proto);
   parsed_descriptor->CopyTo(&parsed_descriptor_proto);
 
   EXPECT_EQ(parsed_descriptor_proto.DebugString(),
-            generated_descriptor_proto.DebugString());
+            generated_decsriptor_proto.DebugString());
 }
 
 #if !defined(GOOGLE_PROTOBUF_CMAKE_BUILD) && !defined(_MSC_VER)
 // Test that generated code has proper descriptors:
 // Touch a descriptor generated from an enormous message to validate special
 // handling for descriptors exceeding the C++ standard's recommended minimum
 // limit for string literal size
 TEST(GeneratedDescriptorTest, EnormousDescriptor) {
   const Descriptor* generated_descriptor =
     TestEnormousDescriptor::descriptor();
@@ skipping 44 matching lines @@
   const unittest::TestExtremeDefaultValues& extreme_default =
       unittest::TestExtremeDefaultValues::default_instance();
 
   EXPECT_EQ(0.0f, extreme_default.zero_float());
   EXPECT_EQ(1.0f, extreme_default.one_float());
   EXPECT_EQ(1.5f, extreme_default.small_float());
   EXPECT_EQ(-1.0f, extreme_default.negative_one_float());
   EXPECT_EQ(-1.5f, extreme_default.negative_float());
   EXPECT_EQ(2.0e8f, extreme_default.large_float());
   EXPECT_EQ(-8e-28f, extreme_default.small_negative_float());
-  EXPECT_EQ(std::numeric_limits<double>::infinity(),
+  EXPECT_EQ(numeric_limits<double>::infinity(),
             extreme_default.inf_double());
-  EXPECT_EQ(-std::numeric_limits<double>::infinity(),
+  EXPECT_EQ(-numeric_limits<double>::infinity(),
             extreme_default.neg_inf_double());
   EXPECT_TRUE(extreme_default.nan_double() != extreme_default.nan_double());
-  EXPECT_EQ(std::numeric_limits<float>::infinity(),
+  EXPECT_EQ(numeric_limits<float>::infinity(),
             extreme_default.inf_float());
-  EXPECT_EQ(-std::numeric_limits<float>::infinity(),
+  EXPECT_EQ(-numeric_limits<float>::infinity(),
             extreme_default.neg_inf_float());
   EXPECT_TRUE(extreme_default.nan_float() != extreme_default.nan_float());
 }
 
 TEST(GeneratedMessageTest, Trigraph) {
   const unittest::TestExtremeDefaultValues& extreme_default =
       unittest::TestExtremeDefaultValues::default_instance();
 
   EXPECT_EQ("? ? ?? ?? ??? ?\?/ ?\?-", extreme_default.cpp_trigraph());
 }
@@ skipping 192 matching lines @@
   // Verify that we can use a char*,length to add to a repeated string field.
   message.add_repeated_string("abcdef", 3);
   EXPECT_EQ(1, message.repeated_string_size());
   EXPECT_EQ("abc", message.repeated_string(0));
 
   // Verify that we can use a char*,length to set a repeated string field.
   message.set_repeated_string(0, "wxyz", 2);
   EXPECT_EQ("wx", message.repeated_string(0));
 }
 
-#if LANG_CXX11
-TEST(GeneratedMessageTest, StringMove) {
-  // Verify that we trigger the move behavior on a scalar setter.
-  protobuf_unittest_no_arena::TestAllTypes message;
-  {
-    string tmp(32, 'a');
-
-    const char* old_data = tmp.data();
-    message.set_optional_string(std::move(tmp));
-    const char* new_data = message.optional_string().data();
-
-    EXPECT_EQ(old_data, new_data);
-    EXPECT_EQ(string(32, 'a'), message.optional_string());
-
-    string tmp2(32, 'b');
-    old_data = tmp2.data();
-    message.set_optional_string(std::move(tmp2));
-    new_data = message.optional_string().data();
-
-    EXPECT_EQ(old_data, new_data);
-    EXPECT_EQ(string(32, 'b'), message.optional_string());
-  }
-
-  // Verify that we trigger the move behavior on a oneof setter.
-  {
-    string tmp(32, 'a');
-
-    const char* old_data = tmp.data();
-    message.set_oneof_string(std::move(tmp));
-    const char* new_data = message.oneof_string().data();
-
-    EXPECT_EQ(old_data, new_data);
-    EXPECT_EQ(string(32, 'a'), message.oneof_string());
-
-    string tmp2(32, 'b');
-    old_data = tmp2.data();
-    message.set_oneof_string(std::move(tmp2));
-    new_data = message.oneof_string().data();
-
-    EXPECT_EQ(old_data, new_data);
-    EXPECT_EQ(string(32, 'b'), message.oneof_string());
-  }
-}
-#endif
-
 
 TEST(GeneratedMessageTest, CopyFrom) {
   unittest::TestAllTypes message1, message2;
 
   TestUtil::SetAllFields(&message1);
   message2.CopyFrom(message1);
   TestUtil::ExpectAllFieldsSet(message2);
 
   // Copying from self should be a no-op.
   message2.CopyFrom(message2);
@@ skipping 79 matching lines @@
 }
 
 TEST(GeneratedMessageTest, CopyConstructor) {
   unittest::TestAllTypes message1;
   TestUtil::SetAllFields(&message1);
 
   unittest::TestAllTypes message2(message1);
   TestUtil::ExpectAllFieldsSet(message2);
 }
 
-TEST(GeneratedMessageTest, CopyConstructorWithArenas) {
-  Arena arena;
-  unittest::TestAllTypes* message1 =
-      Arena::CreateMessage<unittest::TestAllTypes>(&arena);
-  TestUtil::SetAllFields(message1);
-
-  unittest::TestAllTypes message2_stack(*message1);
-  TestUtil::ExpectAllFieldsSet(message2_stack);
-
-  google::protobuf::scoped_ptr<unittest::TestAllTypes> message2_heap(
-      new unittest::TestAllTypes(*message1));
-  TestUtil::ExpectAllFieldsSet(*message2_heap);
-
-  arena.Reset();
-
-  // Verify that the copies are still intact.
-  TestUtil::ExpectAllFieldsSet(message2_stack);
-  TestUtil::ExpectAllFieldsSet(*message2_heap);
-}
-
 TEST(GeneratedMessageTest, CopyAssignmentOperator) {
   unittest::TestAllTypes message1;
   TestUtil::SetAllFields(&message1);
 
   unittest::TestAllTypes message2;
   message2 = message1;
   TestUtil::ExpectAllFieldsSet(message2);
 
   // Make sure that self-assignment does something sane.
   message2.operator=(message2);
@@ skipping 62 matching lines @@
   message1.add_repeated_int32(i);
 
   message1.MergeFrom(message2);
 
   TestUtil::ExpectAllFieldsSet(message1);
 }
 
 #if !defined(PROTOBUF_TEST_NO_DESCRIPTORS) || \
     !defined(GOOGLE_PROTOBUF_NO_RTTI)
 #ifdef PROTOBUF_HAS_DEATH_TEST
-#ifndef NDEBUG
 
 TEST(GeneratedMessageTest, MergeFromSelf) {
   unittest::TestAllTypes message;
-  EXPECT_DEATH(message.MergeFrom(message), "pb[.]cc.*Check failed:");
+  EXPECT_DEATH(message.MergeFrom(message), "Check failed:.*pb[.]cc");
   EXPECT_DEATH(message.MergeFrom(implicit_cast<const Message&>(message)),
-               "pb[.]cc.*Check failed:");
+               "Check failed:.*pb[.]cc");
 }
 
-#endif  // NDEBUG
 #endif  // PROTOBUF_HAS_DEATH_TEST
 #endif  // !PROTOBUF_TEST_NO_DESCRIPTORS || !GOOGLE_PROTOBUF_NO_RTTI
 
 // Test the generated SerializeWithCachedSizesToArray(),
 TEST(GeneratedMessageTest, SerializationToArray) {
   unittest::TestAllTypes message1, message2;
   string data;
   TestUtil::SetAllFields(&message1);
   int size = message1.ByteSize();
   data.resize(size);
@@ skipping 624 matching lines @@
     void NotifyOnCancel(Closure* callback) {
       ADD_FAILURE() << "NotifyOnCancel() not expected during this test.";
     }
   };
 
   GeneratedServiceTest()
     : descriptor_(unittest::TestService::descriptor()),
       foo_(descriptor_->FindMethodByName("Foo")),
       bar_(descriptor_->FindMethodByName("Bar")),
       stub_(&mock_channel_),
-      done_(NewPermanentCallback(&DoNothing)) {}
+      done_(::google::protobuf::internal::NewPermanentCallback(&DoNothing)) {}
 
   virtual void SetUp() {
     ASSERT_TRUE(foo_ != NULL);
     ASSERT_TRUE(bar_ != NULL);
   }
 
   const ServiceDescriptor* descriptor_;
   const MethodDescriptor* foo_;
   const MethodDescriptor* bar_;
 
@@ skipping 864 matching lines @@
     DescriptorPool::generated_pool()->InternalIsFileLoaded(
       "google/protobuf/unittest.proto"));
 }
 
 }  // namespace cpp_unittest
 
 }  // namespace cpp
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google