third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/wire_format_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 1120 matching lines @@
   Utf8ValidationTest() {}
   virtual ~Utf8ValidationTest() {}
   virtual void SetUp() {
   }
 
 };
 
 TEST_F(Utf8ValidationTest, WriteInvalidUTF8String) {
   string wire_buffer;
   protobuf_unittest::OneString input;
-  vector<string> errors;
+  std::vector<string> errors;
   {
     ScopedMemoryLog log;
     WriteMessage(kInvalidUTF8String, &input, &wire_buffer);
     errors = log.GetMessages(ERROR);
   }
 #ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
   ASSERT_EQ(1, errors.size());
   EXPECT_TRUE(StartsWith(errors[0],
                          "String field 'protobuf_unittest.OneString.data' "
                          "contains invalid UTF-8 data when "
                          "serializing a protocol buffer. Use the "
                          "'bytes' type if you intend to send raw bytes."));
 #else
   ASSERT_EQ(0, errors.size());
 #endif  // GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
 }
 
 
 TEST_F(Utf8ValidationTest, ReadInvalidUTF8String) {
   string wire_buffer;
   protobuf_unittest::OneString input;
   WriteMessage(kInvalidUTF8String, &input, &wire_buffer);
   protobuf_unittest::OneString output;
-  vector<string> errors;
+  std::vector<string> errors;
   {
     ScopedMemoryLog log;
     ReadMessage(wire_buffer, &output);
     errors = log.GetMessages(ERROR);
   }
 #ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
   ASSERT_EQ(1, errors.size());
   EXPECT_TRUE(StartsWith(errors[0],
                          "String field 'protobuf_unittest.OneString.data' "
                          "contains invalid UTF-8 data when "
                          "parsing a protocol buffer. Use the "
                          "'bytes' type if you intend to send raw bytes."));
 
 #else
   ASSERT_EQ(0, errors.size());
 #endif  // GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
 }
 
 
 TEST_F(Utf8ValidationTest, WriteValidUTF8String) {
   string wire_buffer;
   protobuf_unittest::OneString input;
-  vector<string> errors;
+  std::vector<string> errors;
   {
     ScopedMemoryLog log;
     WriteMessage(kValidUTF8String, &input, &wire_buffer);
     errors = log.GetMessages(ERROR);
   }
   ASSERT_EQ(0, errors.size());
 }
 
 TEST_F(Utf8ValidationTest, ReadValidUTF8String) {
   string wire_buffer;
   protobuf_unittest::OneString input;
   WriteMessage(kValidUTF8String, &input, &wire_buffer);
   protobuf_unittest::OneString output;
-  vector<string> errors;
+  std::vector<string> errors;
   {
     ScopedMemoryLog log;
     ReadMessage(wire_buffer, &output);
     errors = log.GetMessages(ERROR);
   }
   ASSERT_EQ(0, errors.size());
   EXPECT_EQ(input.data(), output.data());
 }
 
 // Bytes: anything can pass as bytes, use invalid UTF-8 string to test
 TEST_F(Utf8ValidationTest, WriteArbitraryBytes) {
   string wire_buffer;
   protobuf_unittest::OneBytes input;
-  vector<string> errors;
+  std::vector<string> errors;
   {
     ScopedMemoryLog log;
     WriteMessage(kInvalidUTF8String, &input, &wire_buffer);
     errors = log.GetMessages(ERROR);
   }
   ASSERT_EQ(0, errors.size());
 }
 
 TEST_F(Utf8ValidationTest, ReadArbitraryBytes) {
   string wire_buffer;
   protobuf_unittest::OneBytes input;
   WriteMessage(kInvalidUTF8String, &input, &wire_buffer);
   protobuf_unittest::OneBytes output;
-  vector<string> errors;
+  std::vector<string> errors;
   {
     ScopedMemoryLog log;
     ReadMessage(wire_buffer, &output);
     errors = log.GetMessages(ERROR);
   }
   ASSERT_EQ(0, errors.size());
   EXPECT_EQ(input.data(), output.data());
 }
 
 TEST_F(Utf8ValidationTest, ParseRepeatedString) {
   protobuf_unittest::MoreBytes input;
   input.add_data(kValidUTF8String);
   input.add_data(kInvalidUTF8String);
   input.add_data(kInvalidUTF8String);
   string wire_buffer = input.SerializeAsString();
 
   protobuf_unittest::MoreString output;
-  vector<string> errors;
+  std::vector<string> errors;
   {
     ScopedMemoryLog log;
     ReadMessage(wire_buffer, &output);
     errors = log.GetMessages(ERROR);
   }
 #ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
   ASSERT_EQ(2, errors.size());
 #else
   ASSERT_EQ(0, errors.size());
 #endif  // GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
   EXPECT_EQ(wire_buffer, output.SerializeAsString());
 }
 
 // Test the old VerifyUTF8String() function, which may still be called by old
 // generated code.
 TEST_F(Utf8ValidationTest, OldVerifyUTF8String) {
   string data(kInvalidUTF8String);
 
-  vector<string> errors;
+  std::vector<string> errors;
   {
     ScopedMemoryLog log;
     WireFormat::VerifyUTF8String(data.data(), data.size(),
                                  WireFormat::SERIALIZE);
     errors = log.GetMessages(ERROR);
   }
 #ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
   ASSERT_EQ(1, errors.size());
   EXPECT_TRUE(StartsWith(errors[0],
                          "String field contains invalid UTF-8 data when "
                          "serializing a protocol buffer. Use the "
                          "'bytes' type if you intend to send raw bytes."));
 #else
   ASSERT_EQ(0, errors.size());
 #endif
 }
 
 
 }  // namespace
 }  // namespace internal
 }  // namespace protobuf
 }  // namespace google