src/disk_interface_test.cc - third_party/ninja - Git at Google

 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include <assert.h>
 #include <stdio.h>
 #ifdef _WIN32
 #include <io.h>
 #include <windows.h>
 #endif

 #include "disk_interface.h"
 #include "graph.h"
 #include "test.h"

 namespace {

 struct DiskInterfaceTest : public testing::Test {
   virtual void SetUp() {
     // These tests do real disk accesses, so create a temp dir.
     temp_dir_.CreateAndEnter("Ninja-DiskInterfaceTest");
   }

   virtual void TearDown() {
     temp_dir_.Cleanup();
   }

   bool Touch(const char* path) {
     FILE *f = fopen(path, "w");
     if (!f)
       return false;
     return fclose(f) == 0;
   }

   ScopedTempDir temp_dir_;
   RealDiskInterface disk_;
 };

 TEST_F(DiskInterfaceTest, StatMissingFile) {
   string err;
   EXPECT_EQ(0, disk_.Stat("nosuchfile", &err));
   EXPECT_EQ("", err);

   // On Windows, the errno for a file in a nonexistent directory
   // is different.
   EXPECT_EQ(0, disk_.Stat("nosuchdir/nosuchfile", &err));
   EXPECT_EQ("", err);

   // On POSIX systems, the errno is different if a component of the
   // path prefix is not a directory.
   ASSERT_TRUE(Touch("notadir"));
   EXPECT_EQ(0, disk_.Stat("notadir/nosuchfile", &err));
   EXPECT_EQ("", err);
 }

 TEST_F(DiskInterfaceTest, StatBadPath) {
   string err;
 #ifdef _WIN32
   string bad_path("cc:\\foo");
   EXPECT_EQ(-1, disk_.Stat(bad_path, &err));
   EXPECT_NE("", err);
 #else
   string too_long_name(512, 'x');
   EXPECT_EQ(-1, disk_.Stat(too_long_name, &err));
   EXPECT_NE("", err);
 #endif
 }

 TEST_F(DiskInterfaceTest, StatExistingFile) {
   string err;
   ASSERT_TRUE(Touch("file"));
   EXPECT_GT(disk_.Stat("file", &err), 1);
   EXPECT_EQ("", err);
 }

 TEST_F(DiskInterfaceTest, StatExistingDir) {
   string err;
   ASSERT_TRUE(disk_.MakeDir("subdir"));
   ASSERT_TRUE(disk_.MakeDir("subdir/subsubdir"));
   EXPECT_GT(disk_.Stat("..", &err), 1);
   EXPECT_EQ("", err);
   EXPECT_GT(disk_.Stat(".", &err), 1);
   EXPECT_EQ("", err);
   EXPECT_GT(disk_.Stat("subdir", &err), 1);
   EXPECT_EQ("", err);
   EXPECT_GT(disk_.Stat("subdir/subsubdir", &err), 1);
   EXPECT_EQ("", err);

   EXPECT_EQ(disk_.Stat("subdir", &err),
             disk_.Stat("subdir/.", &err));
   EXPECT_EQ(disk_.Stat("subdir", &err),
             disk_.Stat("subdir/subsubdir/..", &err));
   EXPECT_EQ(disk_.Stat("subdir/subsubdir", &err),
             disk_.Stat("subdir/subsubdir/.", &err));
 }

 #ifdef _WIN32
 TEST_F(DiskInterfaceTest, StatCache) {
   string err;

   ASSERT_TRUE(Touch("file1"));
   ASSERT_TRUE(Touch("fiLE2"));
   ASSERT_TRUE(disk_.MakeDir("subdir"));
   ASSERT_TRUE(disk_.MakeDir("subdir/subsubdir"));
   ASSERT_TRUE(Touch("subdir\\subfile1"));
   ASSERT_TRUE(Touch("subdir\\SUBFILE2"));
   ASSERT_TRUE(Touch("subdir\\SUBFILE3"));

   disk_.AllowStatCache(false);
   TimeStamp parent_stat_uncached = disk_.Stat("..", &err);
   disk_.AllowStatCache(true);

   EXPECT_GT(disk_.Stat("FIle1", &err), 1);
   EXPECT_EQ("", err);
   EXPECT_GT(disk_.Stat("file1", &err), 1);
   EXPECT_EQ("", err);

   EXPECT_GT(disk_.Stat("subdir/subfile2", &err), 1);
   EXPECT_EQ("", err);
   EXPECT_GT(disk_.Stat("sUbdir\\suBFile1", &err), 1);
   EXPECT_EQ("", err);

   EXPECT_GT(disk_.Stat("..", &err), 1);
   EXPECT_EQ("", err);
   EXPECT_GT(disk_.Stat(".", &err), 1);
   EXPECT_EQ("", err);
   EXPECT_GT(disk_.Stat("subdir", &err), 1);
   EXPECT_EQ("", err);
   EXPECT_GT(disk_.Stat("subdir/subsubdir", &err), 1);
   EXPECT_EQ("", err);

 #ifndef _MSC_VER // TODO: Investigate why. Also see https://github.com/ninja-build/ninja/pull/1423
   EXPECT_EQ(disk_.Stat("subdir", &err),
             disk_.Stat("subdir/.", &err));
   EXPECT_EQ("", err);
   EXPECT_EQ(disk_.Stat("subdir", &err),
             disk_.Stat("subdir/subsubdir/..", &err));
 #endif
   EXPECT_EQ("", err);
   EXPECT_EQ(disk_.Stat("..", &err), parent_stat_uncached);
   EXPECT_EQ("", err);
   EXPECT_EQ(disk_.Stat("subdir/subsubdir", &err),
             disk_.Stat("subdir/subsubdir/.", &err));
   EXPECT_EQ("", err);

   // Test error cases.
   string bad_path("cc:\\foo");
   EXPECT_EQ(-1, disk_.Stat(bad_path, &err));
   EXPECT_NE("", err); err.clear();
   EXPECT_EQ(-1, disk_.Stat(bad_path, &err));
   EXPECT_NE("", err); err.clear();
   EXPECT_EQ(0, disk_.Stat("nosuchfile", &err));
   EXPECT_EQ("", err);
   EXPECT_EQ(0, disk_.Stat("nosuchdir/nosuchfile", &err));
   EXPECT_EQ("", err);
 }
 #endif

 TEST_F(DiskInterfaceTest, ReadFile) {
   string err;
   std::string content;
   ASSERT_EQ(DiskInterface::NotFound,
             disk_.ReadFile("foobar", &content, &err));
   EXPECT_EQ("", content);
   EXPECT_NE("", err); // actual value is platform-specific
   err.clear();

   const char* kTestFile = "testfile";
   FILE* f = fopen(kTestFile, "wb");
   ASSERT_TRUE(f);
   const char* kTestContent = "test content\nok";
   fprintf(f, "%s", kTestContent);
   ASSERT_EQ(0, fclose(f));

   ASSERT_EQ(DiskInterface::Okay,
             disk_.ReadFile(kTestFile, &content, &err));
   EXPECT_EQ(kTestContent, content);
   EXPECT_EQ("", err);
 }

 TEST_F(DiskInterfaceTest, MakeDirs) {
   string path = "path/with/double//slash/";
   EXPECT_TRUE(disk_.MakeDirs(path.c_str()));
   FILE* f = fopen((path + "a_file").c_str(), "w");
   EXPECT_TRUE(f);
   EXPECT_EQ(0, fclose(f));
 #ifdef _WIN32
   string path2 = "another\\with\\back\\\\slashes\\";
   EXPECT_TRUE(disk_.MakeDirs(path2.c_str()));
   FILE* f2 = fopen((path2 + "a_file").c_str(), "w");
   EXPECT_TRUE(f2);
   EXPECT_EQ(0, fclose(f2));
 #endif
 }

 TEST_F(DiskInterfaceTest, RemoveFile) {
   const char* kFileName = "file-to-remove";
   ASSERT_TRUE(Touch(kFileName));
   EXPECT_EQ(0, disk_.RemoveFile(kFileName));
   EXPECT_EQ(1, disk_.RemoveFile(kFileName));
   EXPECT_EQ(1, disk_.RemoveFile("does not exist"));
 }

 struct StatTest : public StateTestWithBuiltinRules,
                   public DiskInterface {
   StatTest() : scan_(&state_, NULL, NULL, this, NULL) {}

   // DiskInterface implementation.
   virtual TimeStamp Stat(const string& path, string* err) const;
   virtual bool WriteFile(const string& path, const string& contents) {
     assert(false);
     return true;
   }
   virtual bool MakeDir(const string& path) {
     assert(false);
     return false;
   }
   virtual Status ReadFile(const string& path, string* contents, string* err) {
     assert(false);
     return NotFound;
   }
   virtual int RemoveFile(const string& path) {
     assert(false);
     return 0;
   }

   DependencyScan scan_;
   map<string, TimeStamp> mtimes_;
   mutable vector<string> stats_;
 };

 TimeStamp StatTest::Stat(const string& path, string* err) const {
   stats_.push_back(path);
   map<string, TimeStamp>::const_iterator i = mtimes_.find(path);
   if (i == mtimes_.end())
     return 0;  // File not found.
   return i->second;
 }

 TEST_F(StatTest, Simple) {
   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 "build out: cat in\n"));

   Node* out = GetNode("out");
   string err;
   EXPECT_TRUE(out->Stat(this, &err));
   EXPECT_EQ("", err);
   ASSERT_EQ(1u, stats_.size());
   scan_.RecomputeDirty(out, NULL);
   ASSERT_EQ(2u, stats_.size());
   ASSERT_EQ("out", stats_[0]);
   ASSERT_EQ("in",  stats_[1]);
 }

 TEST_F(StatTest, TwoStep) {
   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 "build out: cat mid\n"
 "build mid: cat in\n"));

   Node* out = GetNode("out");
   string err;
   EXPECT_TRUE(out->Stat(this, &err));
   EXPECT_EQ("", err);
   ASSERT_EQ(1u, stats_.size());
   scan_.RecomputeDirty(out, NULL);
   ASSERT_EQ(3u, stats_.size());
   ASSERT_EQ("out", stats_[0]);
   ASSERT_TRUE(GetNode("out")->dirty());
   ASSERT_EQ("mid",  stats_[1]);
   ASSERT_TRUE(GetNode("mid")->dirty());
   ASSERT_EQ("in",  stats_[2]);
 }

 TEST_F(StatTest, Tree) {
   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 "build out: cat mid1 mid2\n"
 "build mid1: cat in11 in12\n"
 "build mid2: cat in21 in22\n"));

   Node* out = GetNode("out");
   string err;
   EXPECT_TRUE(out->Stat(this, &err));
   EXPECT_EQ("", err);
   ASSERT_EQ(1u, stats_.size());
   scan_.RecomputeDirty(out, NULL);
   ASSERT_EQ(1u + 6u, stats_.size());
   ASSERT_EQ("mid1", stats_[1]);
   ASSERT_TRUE(GetNode("mid1")->dirty());
   ASSERT_EQ("in11", stats_[2]);
 }

 TEST_F(StatTest, Middle) {
   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 "build out: cat mid\n"
 "build mid: cat in\n"));

   mtimes_["in"] = 1;
   mtimes_["mid"] = 0;  // missing
   mtimes_["out"] = 1;

   Node* out = GetNode("out");
   string err;
   EXPECT_TRUE(out->Stat(this, &err));
   EXPECT_EQ("", err);
   ASSERT_EQ(1u, stats_.size());
   scan_.RecomputeDirty(out, NULL);
   ASSERT_FALSE(GetNode("in")->dirty());
   ASSERT_TRUE(GetNode("mid")->dirty());
   ASSERT_TRUE(GetNode("out")->dirty());
 }

 }  // namespace
	// Copyright 2011 Google Inc. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include <assert.h>
	#include <stdio.h>
	#ifdef _WIN32
	#include <io.h>
	#include <windows.h>
	#endif

	#include "disk_interface.h"
	#include "graph.h"
	#include "test.h"

	namespace {

	struct DiskInterfaceTest : public testing::Test {
	virtual void SetUp() {
	// These tests do real disk accesses, so create a temp dir.
	temp_dir_.CreateAndEnter("Ninja-DiskInterfaceTest");
	}

	virtual void TearDown() {
	temp_dir_.Cleanup();
	}

	bool Touch(const char* path) {
	FILE *f = fopen(path, "w");
	if (!f)
	return false;
	return fclose(f) == 0;
	}

	ScopedTempDir temp_dir_;
	RealDiskInterface disk_;
	};

	TEST_F(DiskInterfaceTest, StatMissingFile) {
	string err;
	EXPECT_EQ(0, disk_.Stat("nosuchfile", &err));
	EXPECT_EQ("", err);

	// On Windows, the errno for a file in a nonexistent directory
	// is different.
	EXPECT_EQ(0, disk_.Stat("nosuchdir/nosuchfile", &err));
	EXPECT_EQ("", err);

	// On POSIX systems, the errno is different if a component of the
	// path prefix is not a directory.
	ASSERT_TRUE(Touch("notadir"));
	EXPECT_EQ(0, disk_.Stat("notadir/nosuchfile", &err));
	EXPECT_EQ("", err);
	}

	TEST_F(DiskInterfaceTest, StatBadPath) {
	string err;
	#ifdef _WIN32
	string bad_path("cc:\\foo");
	EXPECT_EQ(-1, disk_.Stat(bad_path, &err));
	EXPECT_NE("", err);
	#else
	string too_long_name(512, 'x');
	EXPECT_EQ(-1, disk_.Stat(too_long_name, &err));
	EXPECT_NE("", err);
	#endif
	}

	TEST_F(DiskInterfaceTest, StatExistingFile) {
	string err;
	ASSERT_TRUE(Touch("file"));
	EXPECT_GT(disk_.Stat("file", &err), 1);
	EXPECT_EQ("", err);
	}

	TEST_F(DiskInterfaceTest, StatExistingDir) {
	string err;
	ASSERT_TRUE(disk_.MakeDir("subdir"));
	ASSERT_TRUE(disk_.MakeDir("subdir/subsubdir"));
	EXPECT_GT(disk_.Stat("..", &err), 1);
	EXPECT_EQ("", err);
	EXPECT_GT(disk_.Stat(".", &err), 1);
	EXPECT_EQ("", err);
	EXPECT_GT(disk_.Stat("subdir", &err), 1);
	EXPECT_EQ("", err);
	EXPECT_GT(disk_.Stat("subdir/subsubdir", &err), 1);
	EXPECT_EQ("", err);

	EXPECT_EQ(disk_.Stat("subdir", &err),
	disk_.Stat("subdir/.", &err));
	EXPECT_EQ(disk_.Stat("subdir", &err),
	disk_.Stat("subdir/subsubdir/..", &err));
	EXPECT_EQ(disk_.Stat("subdir/subsubdir", &err),
	disk_.Stat("subdir/subsubdir/.", &err));
	}

	#ifdef _WIN32
	TEST_F(DiskInterfaceTest, StatCache) {
	string err;

	ASSERT_TRUE(Touch("file1"));
	ASSERT_TRUE(Touch("fiLE2"));
	ASSERT_TRUE(disk_.MakeDir("subdir"));
	ASSERT_TRUE(disk_.MakeDir("subdir/subsubdir"));
	ASSERT_TRUE(Touch("subdir\\subfile1"));
	ASSERT_TRUE(Touch("subdir\\SUBFILE2"));
	ASSERT_TRUE(Touch("subdir\\SUBFILE3"));

	disk_.AllowStatCache(false);
	TimeStamp parent_stat_uncached = disk_.Stat("..", &err);
	disk_.AllowStatCache(true);

	EXPECT_GT(disk_.Stat("FIle1", &err), 1);
	EXPECT_EQ("", err);
	EXPECT_GT(disk_.Stat("file1", &err), 1);
	EXPECT_EQ("", err);

	EXPECT_GT(disk_.Stat("subdir/subfile2", &err), 1);
	EXPECT_EQ("", err);
	EXPECT_GT(disk_.Stat("sUbdir\\suBFile1", &err), 1);
	EXPECT_EQ("", err);

	EXPECT_GT(disk_.Stat("..", &err), 1);
	EXPECT_EQ("", err);
	EXPECT_GT(disk_.Stat(".", &err), 1);
	EXPECT_EQ("", err);
	EXPECT_GT(disk_.Stat("subdir", &err), 1);
	EXPECT_EQ("", err);
	EXPECT_GT(disk_.Stat("subdir/subsubdir", &err), 1);
	EXPECT_EQ("", err);

	#ifndef _MSC_VER // TODO: Investigate why. Also see https://github.com/ninja-build/ninja/pull/1423
	EXPECT_EQ(disk_.Stat("subdir", &err),
	disk_.Stat("subdir/.", &err));
	EXPECT_EQ("", err);
	EXPECT_EQ(disk_.Stat("subdir", &err),
	disk_.Stat("subdir/subsubdir/..", &err));
	#endif
	EXPECT_EQ("", err);
	EXPECT_EQ(disk_.Stat("..", &err), parent_stat_uncached);
	EXPECT_EQ("", err);
	EXPECT_EQ(disk_.Stat("subdir/subsubdir", &err),
	disk_.Stat("subdir/subsubdir/.", &err));
	EXPECT_EQ("", err);

	// Test error cases.
	string bad_path("cc:\\foo");
	EXPECT_EQ(-1, disk_.Stat(bad_path, &err));
	EXPECT_NE("", err); err.clear();
	EXPECT_EQ(-1, disk_.Stat(bad_path, &err));
	EXPECT_NE("", err); err.clear();
	EXPECT_EQ(0, disk_.Stat("nosuchfile", &err));
	EXPECT_EQ("", err);
	EXPECT_EQ(0, disk_.Stat("nosuchdir/nosuchfile", &err));
	EXPECT_EQ("", err);
	}
	#endif

	TEST_F(DiskInterfaceTest, ReadFile) {
	string err;
	std::string content;
	ASSERT_EQ(DiskInterface::NotFound,
	disk_.ReadFile("foobar", &content, &err));
	EXPECT_EQ("", content);
	EXPECT_NE("", err); // actual value is platform-specific
	err.clear();

	const char* kTestFile = "testfile";
	FILE* f = fopen(kTestFile, "wb");
	ASSERT_TRUE(f);
	const char* kTestContent = "test content\nok";
	fprintf(f, "%s", kTestContent);
	ASSERT_EQ(0, fclose(f));

	ASSERT_EQ(DiskInterface::Okay,
	disk_.ReadFile(kTestFile, &content, &err));
	EXPECT_EQ(kTestContent, content);
	EXPECT_EQ("", err);
	}

	TEST_F(DiskInterfaceTest, MakeDirs) {
	string path = "path/with/double//slash/";
	EXPECT_TRUE(disk_.MakeDirs(path.c_str()));
	FILE* f = fopen((path + "a_file").c_str(), "w");
	EXPECT_TRUE(f);
	EXPECT_EQ(0, fclose(f));
	#ifdef _WIN32
	string path2 = "another\\with\\back\\\\slashes\\";
	EXPECT_TRUE(disk_.MakeDirs(path2.c_str()));
	FILE* f2 = fopen((path2 + "a_file").c_str(), "w");
	EXPECT_TRUE(f2);
	EXPECT_EQ(0, fclose(f2));
	#endif
	}

	TEST_F(DiskInterfaceTest, RemoveFile) {
	const char* kFileName = "file-to-remove";
	ASSERT_TRUE(Touch(kFileName));
	EXPECT_EQ(0, disk_.RemoveFile(kFileName));
	EXPECT_EQ(1, disk_.RemoveFile(kFileName));
	EXPECT_EQ(1, disk_.RemoveFile("does not exist"));
	}

	struct StatTest : public StateTestWithBuiltinRules,
	public DiskInterface {
	StatTest() : scan_(&state_, NULL, NULL, this, NULL) {}

	// DiskInterface implementation.
	virtual TimeStamp Stat(const string& path, string* err) const;
	virtual bool WriteFile(const string& path, const string& contents) {
	assert(false);
	return true;
	}
	virtual bool MakeDir(const string& path) {
	assert(false);
	return false;
	}
	virtual Status ReadFile(const string& path, string* contents, string* err) {
	assert(false);
	return NotFound;
	}
	virtual int RemoveFile(const string& path) {
	assert(false);
	return 0;
	}

	DependencyScan scan_;
	map<string, TimeStamp> mtimes_;
	mutable vector<string> stats_;
	};

	TimeStamp StatTest::Stat(const string& path, string* err) const {
	stats_.push_back(path);
	map<string, TimeStamp>::const_iterator i = mtimes_.find(path);
	if (i == mtimes_.end())
	return 0; // File not found.
	return i->second;
	}

	TEST_F(StatTest, Simple) {
	ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
	"build out: cat in\n"));

	Node* out = GetNode("out");
	string err;
	EXPECT_TRUE(out->Stat(this, &err));
	EXPECT_EQ("", err);
	ASSERT_EQ(1u, stats_.size());
	scan_.RecomputeDirty(out, NULL);
	ASSERT_EQ(2u, stats_.size());
	ASSERT_EQ("out", stats_[0]);
	ASSERT_EQ("in", stats_[1]);
	}

	TEST_F(StatTest, TwoStep) {
	ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
	"build out: cat mid\n"
	"build mid: cat in\n"));

	Node* out = GetNode("out");
	string err;
	EXPECT_TRUE(out->Stat(this, &err));
	EXPECT_EQ("", err);
	ASSERT_EQ(1u, stats_.size());
	scan_.RecomputeDirty(out, NULL);
	ASSERT_EQ(3u, stats_.size());
	ASSERT_EQ("out", stats_[0]);
	ASSERT_TRUE(GetNode("out")->dirty());
	ASSERT_EQ("mid", stats_[1]);
	ASSERT_TRUE(GetNode("mid")->dirty());
	ASSERT_EQ("in", stats_[2]);
	}

	TEST_F(StatTest, Tree) {
	ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
	"build out: cat mid1 mid2\n"
	"build mid1: cat in11 in12\n"
	"build mid2: cat in21 in22\n"));

	Node* out = GetNode("out");
	string err;
	EXPECT_TRUE(out->Stat(this, &err));
	EXPECT_EQ("", err);
	ASSERT_EQ(1u, stats_.size());
	scan_.RecomputeDirty(out, NULL);
	ASSERT_EQ(1u + 6u, stats_.size());
	ASSERT_EQ("mid1", stats_[1]);
	ASSERT_TRUE(GetNode("mid1")->dirty());
	ASSERT_EQ("in11", stats_[2]);
	}

	TEST_F(StatTest, Middle) {
	ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
	"build out: cat mid\n"
	"build mid: cat in\n"));

	mtimes_["in"] = 1;
	mtimes_["mid"] = 0; // missing
	mtimes_["out"] = 1;

	Node* out = GetNode("out");
	string err;
	EXPECT_TRUE(out->Stat(this, &err));
	EXPECT_EQ("", err);
	ASSERT_EQ(1u, stats_.size());
	scan_.RecomputeDirty(out, NULL);
	ASSERT_FALSE(GetNode("in")->dirty());
	ASSERT_TRUE(GetNode("mid")->dirty());
	ASSERT_TRUE(GetNode("out")->dirty());
	}

	} // namespace