third_party/protobuf: update to upstream r371

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.
 // http://code.google.com/p/protobuf/
 //
 // 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 149 matching lines @@
   EXPECT_EQ(-numeric_limits<double>::infinity(),
             extreme_default.neg_inf_double());
   EXPECT_TRUE(extreme_default.nan_double() != extreme_default.nan_double());
   EXPECT_EQ(numeric_limits<float>::infinity(),
             extreme_default.inf_float());
   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());
+}
+
 TEST(GeneratedMessageTest, Accessors) {
   // Set every field to a unique value then go back and check all those
   // values.
   unittest::TestAllTypes message;
 
   TestUtil::SetAllFields(&message);
   TestUtil::ExpectAllFieldsSet(message);
 
   TestUtil::ModifyRepeatedFields(&message);
   TestUtil::ExpectRepeatedFieldsModified(message);
 }
 
 TEST(GeneratedMessageTest, MutableStringDefault) {
   // mutable_foo() for a string should return a string initialized to its
   // default value.
   unittest::TestAllTypes message;
 
   EXPECT_EQ("hello", *message.mutable_default_string());
 
   // Note that the first time we call mutable_foo(), we get a newly-allocated
   // string, but if we clear it and call it again, we get the same object again.
   // We should verify that it has its default value in both cases.
   message.set_default_string("blah");
   message.Clear();
 
   EXPECT_EQ("hello", *message.mutable_default_string());
 }
 
+TEST(GeneratedMessageTest, ReleaseString) {
+  // Check that release_foo() starts out NULL, and gives us a value
+  // that we can delete after it's been set.
+  unittest::TestAllTypes message;
+
+  EXPECT_EQ(NULL, message.release_default_string());
+  EXPECT_FALSE(message.has_default_string());
+  EXPECT_EQ("hello", message.default_string());
+
+  message.set_default_string("blah");
+  EXPECT_TRUE(message.has_default_string());
+  string* str = message.release_default_string();
+  EXPECT_FALSE(message.has_default_string());
+  ASSERT_TRUE(str != NULL);
+  EXPECT_EQ("blah", *str);
+  delete str;
+
+  EXPECT_EQ(NULL, message.release_default_string());
+  EXPECT_FALSE(message.has_default_string());
+  EXPECT_EQ("hello", message.default_string());
+}
+
+TEST(GeneratedMessageTest, ReleaseMessage) {
+  // Check that release_foo() starts out NULL, and gives us a value
+  // that we can delete after it's been set.
+  unittest::TestAllTypes message;
+
+  EXPECT_EQ(NULL, message.release_optional_nested_message());
+  EXPECT_FALSE(message.has_optional_nested_message());
+
+  message.mutable_optional_nested_message()->set_bb(1);
+  unittest::TestAllTypes::NestedMessage* nest =
+      message.release_optional_nested_message();
+  EXPECT_FALSE(message.has_optional_nested_message());
+  ASSERT_TRUE(nest != NULL);
+  EXPECT_EQ(1, nest->bb());
+  delete nest;
+
+  EXPECT_EQ(NULL, message.release_optional_nested_message());
+  EXPECT_FALSE(message.has_optional_nested_message());
+}
+
 TEST(GeneratedMessageTest, Clear) {
   // Set every field to a unique value, clear the message, then check that
   // it is cleared.
   unittest::TestAllTypes message;
 
   TestUtil::SetAllFields(&message);
   message.Clear();
   TestUtil::ExpectClear(message);
 
   // Unlike with the defaults test, we do NOT expect that requesting embedded
@@ skipping 67 matching lines @@
 
   TestUtil::SetAllFields(&message1);
   message2.CopyFrom(message1);
   TestUtil::ExpectAllFieldsSet(message2);
 
   // Copying from self should be a no-op.
   message2.CopyFrom(message2);
   TestUtil::ExpectAllFieldsSet(message2);
 }
 
+
 TEST(GeneratedMessageTest, SwapWithEmpty) {
   unittest::TestAllTypes message1, message2;
   TestUtil::SetAllFields(&message1);
 
   TestUtil::ExpectAllFieldsSet(message1);
   TestUtil::ExpectClear(message2);
   message1.Swap(&message2);
   TestUtil::ExpectAllFieldsSet(message2);
   TestUtil::ExpectClear(message1);
 }
@@ skipping 74 matching lines @@
 
 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 = message2;
+  message2.operator=(message2);
   TestUtil::ExpectAllFieldsSet(message2);
 }
 
 TEST(GeneratedMessageTest, UpcastCopyFrom) {
   // Test the CopyFrom method that takes in the generic const Message&
   // parameter.
   unittest::TestAllTypes message1, message2;
 
   TestUtil::SetAllFields(&message1);
 
@@ skipping 321 matching lines @@
   message1.mutable_optional_nested_message();
   ASSERT_EQ(sizeof(unittest::TestAllTypes::NestedMessage),
             message1.optional_nested_message().SpaceUsed());
   EXPECT_EQ(previous_size +
             sizeof(unittest::TestAllTypes::NestedMessage),
             message1.SpaceUsed());
 }
 
 #endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
 
+
 TEST(GeneratedMessageTest, FieldConstantValues) {
   unittest::TestRequired message;
   EXPECT_EQ(unittest::TestAllTypes_NestedMessage::kBbFieldNumber, 1);
   EXPECT_EQ(unittest::TestAllTypes::kOptionalInt32FieldNumber, 1);
   EXPECT_EQ(unittest::TestAllTypes::kOptionalgroupFieldNumber, 16);
   EXPECT_EQ(unittest::TestAllTypes::kOptionalNestedMessageFieldNumber, 18);
   EXPECT_EQ(unittest::TestAllTypes::kOptionalNestedEnumFieldNumber, 21);
   EXPECT_EQ(unittest::TestAllTypes::kRepeatedInt32FieldNumber, 31);
   EXPECT_EQ(unittest::TestAllTypes::kRepeatedgroupFieldNumber, 46);
   EXPECT_EQ(unittest::TestAllTypes::kRepeatedNestedMessageFieldNumber, 48);
@@ skipping 71 matching lines @@
 
   EXPECT_EQ(1, unittest::TestEnumWithDupValue_MIN);
   EXPECT_EQ(3, unittest::TestEnumWithDupValue_MAX);
   EXPECT_EQ(4, unittest::TestEnumWithDupValue_ARRAYSIZE);
 
   EXPECT_EQ(unittest::SPARSE_E, unittest::TestSparseEnum_MIN);
   EXPECT_EQ(unittest::SPARSE_C, unittest::TestSparseEnum_MAX);
   EXPECT_EQ(12589235, unittest::TestSparseEnum_ARRAYSIZE);
 
   // Make sure we can take the address of _MIN, _MAX and _ARRAYSIZE.
-  void* nullptr = 0;  // NULL may be integer-type, not pointer-type.
-  EXPECT_NE(nullptr, &unittest::TestAllTypes::NestedEnum_MIN);
-  EXPECT_NE(nullptr, &unittest::TestAllTypes::NestedEnum_MAX);
-  EXPECT_NE(nullptr, &unittest::TestAllTypes::NestedEnum_ARRAYSIZE);
+  void* null_pointer = 0;  // NULL may be integer-type, not pointer-type.
+  EXPECT_NE(null_pointer, &unittest::TestAllTypes::NestedEnum_MIN);
+  EXPECT_NE(null_pointer, &unittest::TestAllTypes::NestedEnum_MAX);
+  EXPECT_NE(null_pointer, &unittest::TestAllTypes::NestedEnum_ARRAYSIZE);
 
-  EXPECT_NE(nullptr, &unittest::ForeignEnum_MIN);
-  EXPECT_NE(nullptr, &unittest::ForeignEnum_MAX);
-  EXPECT_NE(nullptr, &unittest::ForeignEnum_ARRAYSIZE);
+  EXPECT_NE(null_pointer, &unittest::ForeignEnum_MIN);
+  EXPECT_NE(null_pointer, &unittest::ForeignEnum_MAX);
+  EXPECT_NE(null_pointer, &unittest::ForeignEnum_ARRAYSIZE);
 
   // Make sure we can use _MIN, _MAX and _ARRAYSIZE as switch cases.
   switch (unittest::SPARSE_A) {
     case unittest::TestSparseEnum_MIN:
     case unittest::TestSparseEnum_MAX:
     case unittest::TestSparseEnum_ARRAYSIZE:
       break;
     default:
       break;
   }
@@ skipping 391 matching lines @@
     DescriptorPool::generated_pool()->InternalIsFileLoaded(
       "google/protobuf/unittest.proto"));
 }
 
 }  // namespace cpp_unittest
 
 }  // namespace cpp
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google