third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/io/printer_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 103 matching lines @@
 }
 
 TEST(Printer, VariableSubstitution) {
   char buffer[8192];
 
   for (int block_size = 1; block_size < 512; block_size *= 2) {
     ArrayOutputStream output(buffer, sizeof(buffer), block_size);
 
     {
       Printer printer(&output, '$');
-      map<string, string> vars;
+      std::map<string, string> vars;
 
       vars["foo"] = "World";
       vars["bar"] = "$foo$";
       vars["abcdefg"] = "1234";
 
       printer.Print(vars, "Hello $foo$!\nbar = $bar$\n");
       printer.PrintRaw("RawBit\n");
       printer.Print(vars, "$abcdefg$\nA literal dollar sign:  $$");
 
       vars["foo"] = "blah";
@@ skipping 45 matching lines @@
   const string& name() const { return file_; }
 
  private:
   string file_;
 };
 
 // MockDescriptor defines only those members that Printer uses to write out
 // annotations.
 class MockDescriptor {
  public:
-  MockDescriptor(const string& file, const vector<int>& path)
+  MockDescriptor(const string& file, const std::vector<int>& path)
       : file_(file), path_(path) {}
 
   // The mock file in which this descriptor was defined.
   const MockDescriptorFile* file() const { return &file_; }
 
  private:
   // Allows access to GetLocationPath.
   friend class ::google::protobuf::io::Printer;
 
   // Copies the pre-stored path to output.
   void GetLocationPath(std::vector<int>* output) const { *output = path_; }
 
   MockDescriptorFile file_;
-  vector<int> path_;
+  std::vector<int> path_;
 };
 
 TEST(Printer, AnnotateMap) {
   char buffer[8192];
   ArrayOutputStream output(buffer, sizeof(buffer));
   GeneratedCodeInfo info;
   AnnotationProtoCollector<GeneratedCodeInfo> info_collector(&info);
   {
     Printer printer(&output, '$', &info_collector);
-    map<string, string> vars;
+    std::map<string, string> vars;
     vars["foo"] = "3";
     vars["bar"] = "5";
     printer.Print(vars, "012$foo$4$bar$\n");
-    vector<int> path_1;
+    std::vector<int> path_1;
     path_1.push_back(33);
-    vector<int> path_2;
+    std::vector<int> path_2;
     path_2.push_back(11);
     path_2.push_back(22);
     MockDescriptor descriptor_1("path_1", path_1);
     MockDescriptor descriptor_2("path_2", path_2);
     printer.Annotate("foo", "foo", &descriptor_1);
     printer.Annotate("bar", "bar", &descriptor_2);
   }
   buffer[output.ByteCount()] = '\0';
   EXPECT_STREQ("012345\n", buffer);
   ASSERT_EQ(2, info.annotation_size());
@@ skipping 17 matching lines @@
 }
 
 TEST(Printer, AnnotateInline) {
   char buffer[8192];
   ArrayOutputStream output(buffer, sizeof(buffer));
   GeneratedCodeInfo info;
   AnnotationProtoCollector<GeneratedCodeInfo> info_collector(&info);
   {
     Printer printer(&output, '$', &info_collector);
     printer.Print("012$foo$4$bar$\n", "foo", "3", "bar", "5");
-    vector<int> path_1;
+    std::vector<int> path_1;
     path_1.push_back(33);
-    vector<int> path_2;
+    std::vector<int> path_2;
     path_2.push_back(11);
     path_2.push_back(22);
     MockDescriptor descriptor_1("path_1", path_1);
     MockDescriptor descriptor_2("path_2", path_2);
     printer.Annotate("foo", "foo", &descriptor_1);
     printer.Annotate("bar", "bar", &descriptor_2);
   }
   buffer[output.ByteCount()] = '\0';
   EXPECT_STREQ("012345\n", buffer);
   ASSERT_EQ(2, info.annotation_size());
@@ skipping 17 matching lines @@
 }
 
 TEST(Printer, AnnotateRange) {
   char buffer[8192];
   ArrayOutputStream output(buffer, sizeof(buffer));
   GeneratedCodeInfo info;
   AnnotationProtoCollector<GeneratedCodeInfo> info_collector(&info);
   {
     Printer printer(&output, '$', &info_collector);
     printer.Print("012$foo$4$bar$\n", "foo", "3", "bar", "5");
-    vector<int> path;
+    std::vector<int> path;
     path.push_back(33);
     MockDescriptor descriptor("path", path);
     printer.Annotate("foo", "bar", &descriptor);
   }
   buffer[output.ByteCount()] = '\0';
   EXPECT_STREQ("012345\n", buffer);
   ASSERT_EQ(1, info.annotation_size());
   const GeneratedCodeInfo::Annotation* foobar = &info.annotation(0);
   ASSERT_EQ(1, foobar->path_size());
   EXPECT_EQ(33, foobar->path(0));
   EXPECT_EQ("path", foobar->source_file());
   EXPECT_EQ(3, foobar->begin());
   EXPECT_EQ(6, foobar->end());
 }
 
 TEST(Printer, AnnotateEmptyRange) {
   char buffer[8192];
   ArrayOutputStream output(buffer, sizeof(buffer));
   GeneratedCodeInfo info;
   AnnotationProtoCollector<GeneratedCodeInfo> info_collector(&info);
   {
     Printer printer(&output, '$', &info_collector);
     printer.Print("012$foo$4$baz$$bam$$bar$\n", "foo", "3", "bar", "5", "baz",
                   "", "bam", "");
-    vector<int> path;
+    std::vector<int> path;
     path.push_back(33);
     MockDescriptor descriptor("path", path);
     printer.Annotate("baz", "bam", &descriptor);
   }
   buffer[output.ByteCount()] = '\0';
   EXPECT_STREQ("012345\n", buffer);
   ASSERT_EQ(1, info.annotation_size());
   const GeneratedCodeInfo::Annotation* bazbam = &info.annotation(0);
   ASSERT_EQ(1, bazbam->path_size());
   EXPECT_EQ(33, bazbam->path(0));
   EXPECT_EQ("path", bazbam->source_file());
   EXPECT_EQ(5, bazbam->begin());
   EXPECT_EQ(5, bazbam->end());
 }
 
 TEST(Printer, AnnotateDespiteUnrelatedMultipleUses) {
   char buffer[8192];
   ArrayOutputStream output(buffer, sizeof(buffer));
   GeneratedCodeInfo info;
   AnnotationProtoCollector<GeneratedCodeInfo> info_collector(&info);
   {
     Printer printer(&output, '$', &info_collector);
     printer.Print("012$foo$4$foo$$bar$\n", "foo", "3", "bar", "5");
-    vector<int> path;
+    std::vector<int> path;
     path.push_back(33);
     MockDescriptor descriptor("path", path);
     printer.Annotate("bar", "bar", &descriptor);
   }
   buffer[output.ByteCount()] = '\0';
   EXPECT_STREQ("0123435\n", buffer);
   ASSERT_EQ(1, info.annotation_size());
   const GeneratedCodeInfo::Annotation* bar = &info.annotation(0);
   ASSERT_EQ(1, bar->path_size());
   EXPECT_EQ(33, bar->path(0));
   EXPECT_EQ("path", bar->source_file());
   EXPECT_EQ(6, bar->begin());
   EXPECT_EQ(7, bar->end());
 }
 
 TEST(Printer, Indenting) {
   char buffer[8192];
 
   for (int block_size = 1; block_size < 512; block_size *= 2) {
     ArrayOutputStream output(buffer, sizeof(buffer), block_size);
 
     {
       Printer printer(&output, '$');
-      map<string, string> vars;
+      std::map<string, string> vars;
 
       vars["newline"] = "\n";
 
       printer.Print("This is not indented.\n");
       printer.Indent();
       printer.Print("This is indented\nAnd so is this\n");
       printer.Outdent();
       printer.Print("But this is not.");
       printer.Indent();
       printer.Print("  And this is still the same line.\n"
@@ skipping 43 matching lines @@
 }
 
 TEST(Printer, AnnotateMultipleUsesDeath) {
   char buffer[8192];
   ArrayOutputStream output(buffer, sizeof(buffer));
   GeneratedCodeInfo info;
   AnnotationProtoCollector<GeneratedCodeInfo> info_collector(&info);
   {
     Printer printer(&output, '$', &info_collector);
     printer.Print("012$foo$4$foo$\n", "foo", "3");
-    vector<int> path;
+    std::vector<int> path;
     path.push_back(33);
     MockDescriptor descriptor("path", path);
     EXPECT_DEBUG_DEATH(printer.Annotate("foo", "foo", &descriptor), "multiple");
   }
 }
 
 TEST(Printer, AnnotateNegativeLengthDeath) {
   char buffer[8192];
   ArrayOutputStream output(buffer, sizeof(buffer));
   GeneratedCodeInfo info;
   AnnotationProtoCollector<GeneratedCodeInfo> info_collector(&info);
   {
     Printer printer(&output, '$', &info_collector);
     printer.Print("012$foo$4$bar$\n", "foo", "3", "bar", "5");
-    vector<int> path;
+    std::vector<int> path;
     path.push_back(33);
     MockDescriptor descriptor("path", path);
     EXPECT_DEBUG_DEATH(printer.Annotate("bar", "foo", &descriptor), "negative");
   }
 }
 
 TEST(Printer, AnnotateUndefinedDeath) {
   char buffer[8192];
   ArrayOutputStream output(buffer, sizeof(buffer));
   GeneratedCodeInfo info;
   AnnotationProtoCollector<GeneratedCodeInfo> info_collector(&info);
   {
     Printer printer(&output, '$', &info_collector);
     printer.Print("012$foo$4$foo$\n", "foo", "3");
-    vector<int> path;
+    std::vector<int> path;
     path.push_back(33);
     MockDescriptor descriptor("path", path);
     EXPECT_DEBUG_DEATH(printer.Annotate("bar", "bar", &descriptor),
                        "Undefined");
   }
 }
 #endif  // PROTOBUF_HAS_DEATH_TEST
 
 TEST(Printer, WriteFailurePartial) {
   char buffer[17];
@@ skipping 38 matching lines @@
   EXPECT_TRUE(printer.failed());
 
   // Buffer should contain the first 16 bytes written.
   EXPECT_EQ("0123456789abcdef", string(buffer, sizeof(buffer)));
 }
 
 }  // namespace
 }  // namespace io
 }  // namespace protobuf
 }  // namespace google