Update protobuf to r428, part 1.

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 26 matching lines @@
 // are actually testing the parser and other parts of the system at the same
 // time, and that problems in the generator may show up as compile-time errors
 // rather than unittest failures, which may be surprising.  However, testing
 // the output of the C++ generator directly would be very hard.  We can't very
 // well just check it against golden files since those files would have to be
 // updated for any small change; such a test would be very brittle and probably
 // not very helpful.  What we really want to test is that the code compiles
 // correctly and produces the interfaces we expect, which is why this test
 // is written this way.
 
+#include <google/protobuf/compiler/cpp/cpp_unittest.h>
+
 #include <vector>
 
 #include <google/protobuf/unittest.pb.h>
 #include <google/protobuf/unittest_optimize_for.pb.h>
 #include <google/protobuf/unittest_embed_optimize_for.pb.h>
 #include <google/protobuf/unittest_no_generic_services.pb.h>
 #include <google/protobuf/test_util.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/descriptor.h>
 #include <google/protobuf/descriptor.pb.h>
 #include <google/protobuf/dynamic_message.h>
 
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/stubs/strutil.h>
 #include <google/protobuf/stubs/substitute.h>
 #include <google/protobuf/testing/googletest.h>
 #include <gtest/gtest.h>
-#include <google/protobuf/stubs/stl_util-inl.h>
+#include <google/protobuf/stubs/stl_util.h>
 
 namespace google {
 namespace protobuf {
 namespace compiler {
 namespace cpp {
 
 // Can't use an anonymous namespace here due to brokenness of Tru64 compiler.
 namespace cpp_unittest {
 
+namespace protobuf_unittest = ::protobuf_unittest;
+
 
 class MockErrorCollector : public MultiFileErrorCollector {
  public:
   MockErrorCollector() {}
   ~MockErrorCollector() {}
 
   string text_;
 
   // implements ErrorCollector ---------------------------------------
   void AddError(const string& filename, int line, int column,
@@ skipping 80 matching lines @@
   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, ExtremeSmallIntegerDefault) {
+  const unittest::TestExtremeDefaultValues& extreme_default =
+      unittest::TestExtremeDefaultValues::default_instance();
+  EXPECT_EQ(-0x80000000, kint32min);
+  EXPECT_EQ(GOOGLE_LONGLONG(-0x8000000000000000), kint64min);
+  EXPECT_EQ(kint32min, extreme_default.really_small_int32());
+  EXPECT_EQ(kint64min, extreme_default.really_small_int64());
+}
+
 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, StringDefaults) {
+  unittest::TestExtremeDefaultValues message;
+  // Check if '\000' can be used in default string value.
+  EXPECT_EQ(string("hel\000lo", 6), message.string_with_zero());
+  EXPECT_EQ(string("wor\000ld", 6), message.bytes_with_zero());
+}
+
 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");
@@ skipping 22 matching lines @@
       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, SetAllocatedString) {
+  // Check that set_allocated_foo() works for strings.
+  unittest::TestAllTypes message;
+
+  EXPECT_FALSE(message.has_optional_string());
+  const string kHello("hello");
+  message.set_optional_string(kHello);
+  EXPECT_TRUE(message.has_optional_string());
+
+  message.set_allocated_optional_string(NULL);
+  EXPECT_FALSE(message.has_optional_string());
+  EXPECT_EQ("", message.optional_string());
+
+  message.set_allocated_optional_string(new string(kHello));
+  EXPECT_TRUE(message.has_optional_string());
+  EXPECT_EQ(kHello, message.optional_string());
+}
+
+TEST(GeneratedMessageTest, SetAllocatedMessage) {
+  // Check that set_allocated_foo() can be called in all cases.
+  unittest::TestAllTypes message;
+
+  EXPECT_FALSE(message.has_optional_nested_message());
+
+  message.mutable_optional_nested_message()->set_bb(1);
+  EXPECT_TRUE(message.has_optional_nested_message());
+
+  message.set_allocated_optional_nested_message(NULL);
+  EXPECT_FALSE(message.has_optional_nested_message());
+  EXPECT_EQ(&unittest::TestAllTypes::NestedMessage::default_instance(),
+            &message.optional_nested_message());
+
+  message.mutable_optional_nested_message()->set_bb(1);
+  unittest::TestAllTypes::NestedMessage* nest =
+      message.release_optional_nested_message();
+  ASSERT_TRUE(nest != NULL);
+  EXPECT_FALSE(message.has_optional_nested_message());
+
+  message.set_allocated_optional_nested_message(nest);
+  EXPECT_TRUE(message.has_optional_nested_message());
+  EXPECT_EQ(1, message.optional_nested_message().bb());
+}
+
 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 431 matching lines @@
   // test_bad_identifiers.proto successfully compiled, then it works.  The
   // following is just a token usage to insure that the code is, in fact,
   // being compiled and linked.
 
   protobuf_unittest::TestConflictingSymbolNames message;
   message.set_uint32(1);
   EXPECT_EQ(3, message.ByteSize());
 
   message.set_friend_(5);
   EXPECT_EQ(5, message.friend_());
+
+  // Instantiate extension template functions to test conflicting template
+  // parameter names.
+  typedef protobuf_unittest::TestConflictingSymbolNamesExtension ExtensionMessage;
+  message.AddExtension(ExtensionMessage::repeated_int32_ext, 123);
+  EXPECT_EQ(123,
+            message.GetExtension(ExtensionMessage::repeated_int32_ext, 0));
 }
 
 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS
 
 TEST(GeneratedMessageTest, TestOptimizedForSize) {
   // We rely on the tests in reflection_ops_unittest and wire_format_unittest
   // to really test that reflection-based methods work.  Here we are mostly
   // just making sure that TestOptimizedForSize actually builds and seems to
   // function.
 
@@ skipping 154 matching lines @@
   // Make sure we can take the address of _MIN, _MAX and _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(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.
+  // Make sure we can use _MIN and _MAX as switch cases.
   switch (unittest::SPARSE_A) {
     case unittest::TestSparseEnum_MIN:
     case unittest::TestSparseEnum_MAX:
-    case unittest::TestSparseEnum_ARRAYSIZE:
       break;
     default:
       break;
   }
 }
 
 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS
 
 TEST(GeneratedEnumTest, Name) {
   // "Names" in the presence of dup values are a bit arbitrary.
@@ skipping 385 matching lines @@
     DescriptorPool::generated_pool()->InternalIsFileLoaded(
       "google/protobuf/unittest.proto"));
 }
 
 }  // namespace cpp_unittest
 
 }  // namespace cpp
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google