Revert https://codereview.chromium.org/1291903002 (protobuf roll).

third_party/protobuf/src/google/protobuf/compiler/importer_unittest.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
+// 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.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
@@ skipping 12 matching lines @@
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Author: kenton@google.com (Kenton Varda)
 //  Based on original Protocol Buffers design by
 //  Sanjay Ghemawat, Jeff Dean, and others.
 
 #include <google/protobuf/stubs/hash.h>
-#include <memory>
-#ifndef _SHARED_PTR_H
-#include <google/protobuf/stubs/shared_ptr.h>
-#endif
 
 #include <google/protobuf/compiler/importer.h>
 #include <google/protobuf/descriptor.h>
-#include <google/protobuf/testing/file.h>
 #include <google/protobuf/io/zero_copy_stream_impl.h>
 
-#include <google/protobuf/stubs/map_util.h>
+#include <google/protobuf/stubs/map-util.h>
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/testing/file.h>
 #include <google/protobuf/stubs/strutil.h>
 #include <google/protobuf/stubs/substitute.h>
 #include <google/protobuf/testing/googletest.h>
 #include <gtest/gtest.h>
 
 namespace google {
 namespace protobuf {
 namespace compiler {
 
 namespace {
 
-bool FileExists(const string& path) {
-  return File::Exists(path);
-}
-
 #define EXPECT_SUBSTRING(needle, haystack) \
   EXPECT_PRED_FORMAT2(testing::IsSubstring, (needle), (haystack))
 
 class MockErrorCollector : public MultiFileErrorCollector {
  public:
   MockErrorCollector() {}
   ~MockErrorCollector() {}
 
   string text_;
 
@@ skipping 20 matching lines @@
   // implements SourceTree -------------------------------------------
   io::ZeroCopyInputStream* Open(const string& filename) {
     const char* contents = FindPtrOrNull(files_, filename);
     if (contents == NULL) {
       return NULL;
     } else {
       return new io::ArrayInputStream(contents, strlen(contents));
     }
   }
 
-  string GetLastErrorMessage() {
-    return "File not found.";
-  }
-
  private:
   hash_map<string, const char*> files_;
 };
 
 // ===================================================================
 
 class ImporterTest : public testing::Test {
  protected:
   ImporterTest()
     : importer_(&source_tree_, &error_collector_) {}
@@ skipping 98 matching lines @@
   EXPECT_EQ(
     "recursive1.proto:-1:0: File recursively imports itself: recursive1.proto "
       "-> recursive2.proto -> recursive1.proto\n"
     "recursive2.proto:-1:0: Import \"recursive1.proto\" was not found "
       "or had errors.\n"
     "recursive1.proto:-1:0: Import \"recursive2.proto\" was not found "
       "or had errors.\n",
     error_collector_.text_);
 }
 
+// TODO(sanjay): The MapField tests below more properly belong in
+// descriptor_unittest, but are more convenient to test here.
+TEST_F(ImporterTest, MapFieldValid) {
+  AddFile(
+      "map.proto",
+      "syntax = \"proto2\";\n"
+      "message Item {\n"
+      "  required string key = 1;\n"
+      "}\n"
+      "message Map {\n"
+      "  repeated Item items = 1 [experimental_map_key = \"key\"];\n"
+      "}\n"
+      );
+  const FileDescriptor* file = importer_.Import("map.proto");
+  ASSERT_TRUE(file != NULL) << error_collector_.text_;
+  EXPECT_EQ("", error_collector_.text_);
+
+  // Check that Map::items points to Item::key
+  const Descriptor* item_type = file->FindMessageTypeByName("Item");
+  ASSERT_TRUE(item_type != NULL);
+  const Descriptor* map_type = file->FindMessageTypeByName("Map");
+  ASSERT_TRUE(map_type != NULL);
+  const FieldDescriptor* key_field = item_type->FindFieldByName("key");
+  ASSERT_TRUE(key_field != NULL);
+  const FieldDescriptor* items_field = map_type->FindFieldByName("items");
+  ASSERT_TRUE(items_field != NULL);
+  EXPECT_EQ(items_field->experimental_map_key(), key_field);
+}
+
+TEST_F(ImporterTest, MapFieldNotRepeated) {
+  AddFile(
+      "map.proto",
+      "syntax = \"proto2\";\n"
+      "message Item {\n"
+      "  required string key = 1;\n"
+      "}\n"
+      "message Map {\n"
+      "  required Item items = 1 [experimental_map_key = \"key\"];\n"
+      "}\n"
+      );
+  EXPECT_TRUE(importer_.Import("map.proto") == NULL);
+  EXPECT_SUBSTRING("only allowed for repeated fields", error());
+}
+
+TEST_F(ImporterTest, MapFieldNotMessageType) {
+  AddFile(
+      "map.proto",
+      "syntax = \"proto2\";\n"
+      "message Map {\n"
+      "  repeated int32 items = 1 [experimental_map_key = \"key\"];\n"
+      "}\n"
+      );
+  EXPECT_TRUE(importer_.Import("map.proto") == NULL);
+  EXPECT_SUBSTRING("only allowed for fields with a message type", error());
+}
+
+TEST_F(ImporterTest, MapFieldTypeNotFound) {
+  AddFile(
+      "map.proto",
+      "syntax = \"proto2\";\n"
+      "message Map {\n"
+      "  repeated Unknown items = 1 [experimental_map_key = \"key\"];\n"
+      "}\n"
+      );
+  EXPECT_TRUE(importer_.Import("map.proto") == NULL);
+  EXPECT_SUBSTRING("not defined", error());
+}
+
+TEST_F(ImporterTest, MapFieldKeyNotFound) {
+  AddFile(
+      "map.proto",
+      "syntax = \"proto2\";\n"
+      "message Item {\n"
+      "  required string key = 1;\n"
+      "}\n"
+      "message Map {\n"
+      "  repeated Item items = 1 [experimental_map_key = \"badkey\"];\n"
+      "}\n"
+      );
+  EXPECT_TRUE(importer_.Import("map.proto") == NULL);
+  EXPECT_SUBSTRING("Could not find field", error());
+}
+
+TEST_F(ImporterTest, MapFieldKeyRepeated) {
+  AddFile(
+      "map.proto",
+      "syntax = \"proto2\";\n"
+      "message Item {\n"
+      "  repeated string key = 1;\n"
+      "}\n"
+      "message Map {\n"
+      "  repeated Item items = 1 [experimental_map_key = \"key\"];\n"
+      "}\n"
+      );
+  EXPECT_TRUE(importer_.Import("map.proto") == NULL);
+  EXPECT_SUBSTRING("must not name a repeated field", error());
+}
+
+TEST_F(ImporterTest, MapFieldKeyNotScalar) {
+  AddFile(
+      "map.proto",
+      "syntax = \"proto2\";\n"
+      "message ItemKey { }\n"
+      "message Item {\n"
+      "  required ItemKey key = 1;\n"
+      "}\n"
+      "message Map {\n"
+      "  repeated Item items = 1 [experimental_map_key = \"key\"];\n"
+      "}\n"
+      );
+  EXPECT_TRUE(importer_.Import("map.proto") == NULL);
+  EXPECT_SUBSTRING("must name a scalar or string", error());
+}
 
 // ===================================================================
 
 class DiskSourceTreeTest : public testing::Test {
  protected:
   virtual void SetUp() {
     dirnames_.push_back(TestTempDir() + "/test_proto2_import_path_1");
     dirnames_.push_back(TestTempDir() + "/test_proto2_import_path_2");
 
     for (int i = 0; i < dirnames_.size(); i++) {
-      if (FileExists(dirnames_[i])) {
+      if (File::Exists(dirnames_[i])) {
         File::DeleteRecursively(dirnames_[i], NULL, NULL);
       }
-      GOOGLE_CHECK_OK(File::CreateDir(dirnames_[i], 0777));
+      GOOGLE_CHECK(File::CreateDir(dirnames_[i].c_str(), DEFAULT_FILE_MODE));
     }
   }
 
   virtual void TearDown() {
     for (int i = 0; i < dirnames_.size(); i++) {
-      if (FileExists(dirnames_[i])) {
-        File::DeleteRecursively(dirnames_[i], NULL, NULL);
-      }
+      File::DeleteRecursively(dirnames_[i], NULL, NULL);
     }
   }
 
   void AddFile(const string& filename, const char* contents) {
-    GOOGLE_CHECK_OK(File::SetContents(filename, contents, true));
+    File::WriteStringToFileOrDie(contents, filename);
   }
 
   void AddSubdir(const string& dirname) {
-    GOOGLE_CHECK_OK(File::CreateDir(dirname, 0777));
+    GOOGLE_CHECK(File::CreateDir(dirname.c_str(), DEFAULT_FILE_MODE));
   }
 
   void ExpectFileContents(const string& filename,
                           const char* expected_contents) {
-    google::protobuf::scoped_ptr<io::ZeroCopyInputStream> input(source_tree_.Open(filename));
+    scoped_ptr<io::ZeroCopyInputStream> input(source_tree_.Open(filename));
 
     ASSERT_FALSE(input == NULL);
 
     // Read all the data from the file.
     string file_contents;
     const void* data;
     int size;
     while (input->Next(&data, &size)) {
       file_contents.append(reinterpret_cast<const char*>(data), size);
     }
 
     EXPECT_EQ(expected_contents, file_contents);
   }
 
-  void ExpectCannotOpenFile(const string& filename,
-                            const string& error_message) {
-    google::protobuf::scoped_ptr<io::ZeroCopyInputStream> input(source_tree_.Open(filename));
+  void ExpectFileNotFound(const string& filename) {
+    scoped_ptr<io::ZeroCopyInputStream> input(source_tree_.Open(filename));
     EXPECT_TRUE(input == NULL);
-    EXPECT_EQ(error_message, source_tree_.GetLastErrorMessage());
   }
 
   DiskSourceTree source_tree_;
 
   // Paths of two on-disk directories to use during the test.
   vector<string> dirnames_;
 };
 
 TEST_F(DiskSourceTreeTest, MapRoot) {
   // Test opening a file in a directory that is mapped to the root of the
   // source tree.
   AddFile(dirnames_[0] + "/foo", "Hello World!");
   source_tree_.MapPath("", dirnames_[0]);
 
   ExpectFileContents("foo", "Hello World!");
-  ExpectCannotOpenFile("bar", "File not found.");
+  ExpectFileNotFound("bar");
 }
 
 TEST_F(DiskSourceTreeTest, MapDirectory) {
   // Test opening a file in a directory that is mapped to somewhere other
   // than the root of the source tree.
 
   AddFile(dirnames_[0] + "/foo", "Hello World!");
   source_tree_.MapPath("baz", dirnames_[0]);
 
   ExpectFileContents("baz/foo", "Hello World!");
-  ExpectCannotOpenFile("baz/bar", "File not found.");
-  ExpectCannotOpenFile("foo", "File not found.");
-  ExpectCannotOpenFile("bar", "File not found.");
+  ExpectFileNotFound("baz/bar");
+  ExpectFileNotFound("foo");
+  ExpectFileNotFound("bar");
 
   // Non-canonical file names should not work.
-  ExpectCannotOpenFile("baz//foo",
-                       "Backslashes, consecutive slashes, \".\", or \"..\" are "
-                       "not allowed in the virtual path");
-  ExpectCannotOpenFile("baz/../baz/foo",
-                       "Backslashes, consecutive slashes, \".\", or \"..\" are "
-                       "not allowed in the virtual path");
-  ExpectCannotOpenFile("baz/./foo",
-                       "Backslashes, consecutive slashes, \".\", or \"..\" are "
-                       "not allowed in the virtual path");
-  ExpectCannotOpenFile("baz/foo/", "File not found.");
+  ExpectFileNotFound("baz//foo");
+  ExpectFileNotFound("baz/../baz/foo");
+  ExpectFileNotFound("baz/./foo");
+  ExpectFileNotFound("baz/foo/");
 }
 
 TEST_F(DiskSourceTreeTest, NoParent) {
   // Test that we cannot open files in a parent of a mapped directory.
 
   AddFile(dirnames_[0] + "/foo", "Hello World!");
   AddSubdir(dirnames_[0] + "/bar");
   AddFile(dirnames_[0] + "/bar/baz", "Blah.");
   source_tree_.MapPath("", dirnames_[0] + "/bar");
 
   ExpectFileContents("baz", "Blah.");
-  ExpectCannotOpenFile("../foo",
-                       "Backslashes, consecutive slashes, \".\", or \"..\" are "
-                       "not allowed in the virtual path");
-  ExpectCannotOpenFile("../bar/baz",
-                       "Backslashes, consecutive slashes, \".\", or \"..\" are "
-                       "not allowed in the virtual path");
+  ExpectFileNotFound("../foo");
+  ExpectFileNotFound("../bar/baz");
 }
 
 TEST_F(DiskSourceTreeTest, MapFile) {
   // Test opening a file that is mapped directly into the source tree.
 
   AddFile(dirnames_[0] + "/foo", "Hello World!");
   source_tree_.MapPath("foo", dirnames_[0] + "/foo");
 
   ExpectFileContents("foo", "Hello World!");
-  ExpectCannotOpenFile("bar", "File not found.");
+  ExpectFileNotFound("bar");
 }
 
 TEST_F(DiskSourceTreeTest, SearchMultipleDirectories) {
   // Test mapping and searching multiple directories.
 
   AddFile(dirnames_[0] + "/foo", "Hello World!");
   AddFile(dirnames_[1] + "/foo", "This file should be hidden.");
   AddFile(dirnames_[1] + "/bar", "Goodbye World!");
   source_tree_.MapPath("", dirnames_[0]);
   source_tree_.MapPath("", dirnames_[1]);
 
   ExpectFileContents("foo", "Hello World!");
   ExpectFileContents("bar", "Goodbye World!");
-  ExpectCannotOpenFile("baz", "File not found.");
+  ExpectFileNotFound("baz");
 }
 
 TEST_F(DiskSourceTreeTest, OrderingTrumpsSpecificity) {
   // Test that directories are always searched in order, even when a latter
   // directory is more-specific than a former one.
 
   // Create the "bar" directory so we can put a file in it.
-  GOOGLE_CHECK_OK(File::CreateDir(dirnames_[0] + "/bar", 0777));
+  ASSERT_TRUE(File::CreateDir((dirnames_[0] + "/bar").c_str(),
+                              DEFAULT_FILE_MODE));
 
   // Add files and map paths.
   AddFile(dirnames_[0] + "/bar/foo", "Hello World!");
   AddFile(dirnames_[1] + "/foo", "This file should be hidden.");
   source_tree_.MapPath("", dirnames_[0]);
   source_tree_.MapPath("bar", dirnames_[1]);
 
   // Check.
   ExpectFileContents("bar/foo", "Hello World!");
 }
@@ skipping 123 matching lines @@
   // Accept NULL as output parameter.
   EXPECT_TRUE(source_tree_.VirtualFileToDiskFile("bar/foo", NULL));
   EXPECT_FALSE(source_tree_.VirtualFileToDiskFile("baz/foo", NULL));
 }
 
 }  // namespace
 
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google