blob: 71a9d1d41390d2df0e9bde2207a3e48d73091146 [file] [log] [blame]
// Copyright 2018 The Bazel Authors. 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 "src/tools/runfiles/runfiles.h"
#ifdef COMPILER_MSVC
#include <windows.h>
#endif // COMPILER_MSVC
#include <fstream>
#include <memory>
#include <string>
#include <vector>
#include "gtest/gtest.h"
#include "src/main/cpp/util/file.h"
#define _T(x) #x
#define T(x) _T(x)
#define LINE() T(__LINE__)
namespace bazel {
namespace runfiles {
namespace {
using bazel::runfiles::testing::TestOnly_IsAbsolute;
using std::cerr;
using std::endl;
using std::pair;
using std::string;
using std::unique_ptr;
using std::vector;
class RunfilesTest : public ::testing::Test {
protected:
// Create a temporary file that is deleted with the destructor.
class MockFile {
public:
// Create an empty file with the given name under $TEST_TMPDIR.
static MockFile* Create(const string& name);
// Create a file with the given name and contents under $TEST_TMPDIR.
// The method ensures to create all parent directories, so `name` is allowed
// to contain directory components.
static MockFile* Create(const string& name, const vector<string>& lines);
~MockFile();
const string& Path() const { return path_; }
private:
MockFile(const string& path) : path_(path) {}
MockFile(const MockFile&) = delete;
MockFile(MockFile&&) = delete;
MockFile& operator=(const MockFile&) = delete;
MockFile& operator=(MockFile&&) = delete;
const string path_;
};
static string GetTemp();
};
string RunfilesTest::GetTemp() {
#ifdef COMPILER_MSVC
DWORD size = ::GetEnvironmentVariableA("TEST_TMPDIR", NULL, 0);
if (size == 0) {
return std::move(string()); // unset or empty envvar
}
unique_ptr<char[]> value(new char[size]);
::GetEnvironmentVariableA("TEST_TMPDIR", value.get(), size);
return std::move(string(value.get()));
#else
char* result = getenv("TEST_TMPDIR");
return result != NULL ? std::move(string(result)) : std::move(string());
#endif
}
RunfilesTest::MockFile* RunfilesTest::MockFile::Create(const string& name) {
return Create(name, vector<string>());
}
RunfilesTest::MockFile* RunfilesTest::MockFile::Create(
const string& name, const vector<string>& lines) {
if (name.find("..") != string::npos || TestOnly_IsAbsolute(name)) {
cerr << "WARNING: " << __FILE__ << "(" << __LINE__ << "): bad name: \""
<< name << "\"" << endl;
return nullptr;
}
string tmp(std::move(RunfilesTest::GetTemp()));
if (tmp.empty()) {
cerr << "WARNING: " << __FILE__ << "(" << __LINE__
<< "): $TEST_TMPDIR is empty" << endl;
return nullptr;
}
string path(tmp + "/" + name);
string dirname = blaze_util::Dirname(path);
if (!blaze_util::MakeDirectories(dirname, 0777)) {
cerr << "WARNING: " << __FILE__ << "(" << __LINE__ << "): MakeDirectories("
<< dirname << ") failed" << endl;
return nullptr;
}
auto stm = std::ofstream(path);
for (auto i : lines) {
stm << i << std::endl;
}
return new MockFile(path);
}
RunfilesTest::MockFile::~MockFile() { std::remove(path_.c_str()); }
TEST_F(RunfilesTest, CannotCreateManifestBasedRunfilesDueToBadManifest) {
unique_ptr<MockFile> mf(
MockFile::Create("foo" LINE() ".runfiles_manifest", {"a b", "nospace"}));
EXPECT_TRUE(mf != nullptr);
string error;
unique_ptr<Runfiles> r(Runfiles::CreateManifestBased(mf->Path(), &error));
ASSERT_EQ(r, nullptr);
EXPECT_NE(error.find("bad runfiles manifest entry"), string::npos);
EXPECT_NE(error.find("line #2: \"nospace\""), string::npos);
}
TEST_F(RunfilesTest, ManifestBasedRunfilesRlocation) {
unique_ptr<MockFile> mf(
MockFile::Create("foo" LINE() ".runfiles_manifest", {"a/b c/d"}));
EXPECT_TRUE(mf != nullptr);
string error;
unique_ptr<Runfiles> r(Runfiles::CreateManifestBased(mf->Path(), &error));
ASSERT_NE(r, nullptr);
EXPECT_TRUE(error.empty());
EXPECT_EQ(r->Rlocation("a/b"), "c/d");
EXPECT_EQ(r->Rlocation("c/d"), "");
EXPECT_EQ(r->Rlocation(""), "");
EXPECT_EQ(r->Rlocation("foo"), "");
EXPECT_EQ(r->Rlocation("foo/"), "");
EXPECT_EQ(r->Rlocation("foo/bar"), "");
EXPECT_EQ(r->Rlocation("foo/.."), "");
EXPECT_EQ(r->Rlocation("/Foo"), "/Foo");
EXPECT_EQ(r->Rlocation("c:/Foo"), "c:/Foo");
EXPECT_EQ(r->Rlocation("c:\\Foo"), "c:\\Foo");
}
TEST_F(RunfilesTest, DirectoryBasedRunfilesRlocation) {
string error;
unique_ptr<Runfiles> r(Runfiles::CreateDirectoryBased("whatever", &error));
ASSERT_NE(r, nullptr);
EXPECT_TRUE(error.empty());
EXPECT_EQ(r->Rlocation("a/b"), "whatever/a/b");
EXPECT_EQ(r->Rlocation("c/d"), "whatever/c/d");
EXPECT_EQ(r->Rlocation(""), "");
EXPECT_EQ(r->Rlocation("foo"), "whatever/foo");
EXPECT_EQ(r->Rlocation("foo/"), "whatever/foo/");
EXPECT_EQ(r->Rlocation("foo/bar"), "whatever/foo/bar");
EXPECT_EQ(r->Rlocation("foo/.."), "");
EXPECT_EQ(r->Rlocation("/Foo"), "/Foo");
EXPECT_EQ(r->Rlocation("c:/Foo"), "c:/Foo");
EXPECT_EQ(r->Rlocation("c:\\Foo"), "c:\\Foo");
}
TEST_F(RunfilesTest, ManifestBasedRunfilesEnvVars) {
const vector<string> suffixes({"/MANIFEST", ".runfiles_manifest",
"runfiles_manifest", ".runfiles", ".manifest",
".txt"});
for (vector<string>::size_type i = 0; i < suffixes.size(); ++i) {
unique_ptr<MockFile> mf(
MockFile::Create(string("foo" LINE()) + suffixes[i]));
EXPECT_TRUE(mf != nullptr) << " (suffix=\"" << suffixes[i] << "\")";
string error;
unique_ptr<Runfiles> r(Runfiles::CreateManifestBased(mf->Path(), &error));
ASSERT_NE(r, nullptr) << " (suffix=\"" << suffixes[i] << "\")";
EXPECT_TRUE(error.empty());
// The object can compute the runfiles directory when i=0 and i=1, but not
// when i>1 because the manifest file's name doesn't end in a well-known
// way.
const string expected_runfiles_dir(
i < 2 ? mf->Path().substr(0, mf->Path().size() - 9 /* "_manifest" */)
: "");
vector<pair<string, string> > expected(
{{"RUNFILES_MANIFEST_FILE", mf->Path()},
{"JAVA_RUNFILES", expected_runfiles_dir}});
EXPECT_EQ(r->EnvVars(), expected) << " (suffix=\"" << suffixes[i] << "\")";
}
}
TEST_F(RunfilesTest, DirectoryBasedRunfilesEnvVars) {
string error;
unique_ptr<Runfiles> r(
Runfiles::CreateDirectoryBased("runfiles/dir", &error));
ASSERT_NE(r, nullptr);
EXPECT_TRUE(error.empty());
vector<pair<string, string> > expected(
{{"RUNFILES_DIR", "runfiles/dir"}, {"JAVA_RUNFILES", "runfiles/dir"}});
EXPECT_EQ(r->EnvVars(), expected);
}
TEST_F(RunfilesTest, FailsToCreateManifestBasedBecauseManifestDoesNotExist) {
string error;
unique_ptr<Runfiles> r(
Runfiles::CreateManifestBased("non-existent-file", &error));
ASSERT_EQ(r, nullptr);
EXPECT_NE(error.find("cannot open runfiles manifest"), string::npos);
}
TEST_F(RunfilesTest, MockFileTest) {
{
unique_ptr<MockFile> mf(MockFile::Create(string("foo" LINE() "/..")));
EXPECT_TRUE(mf == nullptr);
}
{
unique_ptr<MockFile> mf(MockFile::Create(string("/Foo" LINE())));
EXPECT_TRUE(mf == nullptr);
}
{
unique_ptr<MockFile> mf(MockFile::Create(string("C:/Foo" LINE())));
EXPECT_TRUE(mf == nullptr);
}
string path;
{
unique_ptr<MockFile> mf(MockFile::Create(string("foo" LINE() "/bar1/qux")));
EXPECT_TRUE(mf != nullptr);
path = mf->Path();
std::ifstream stm(path);
EXPECT_TRUE(stm.good());
string actual;
stm >> actual;
EXPECT_TRUE(actual.empty());
}
{
std::ifstream stm(path);
EXPECT_FALSE(stm.good());
}
{
unique_ptr<MockFile> mf(
MockFile::Create(string("foo" LINE() "/bar2/qux"), vector<string>()));
EXPECT_TRUE(mf != nullptr);
path = mf->Path();
std::ifstream stm(path);
EXPECT_TRUE(stm.good());
string actual;
stm >> actual;
EXPECT_TRUE(actual.empty());
}
{
std::ifstream stm(path);
EXPECT_FALSE(stm.good());
}
{
unique_ptr<MockFile> mf(
MockFile::Create(string("foo" LINE() "/bar3/qux"),
{"hello world", "you are beautiful"}));
EXPECT_TRUE(mf != nullptr);
path = mf->Path();
std::ifstream stm(path);
EXPECT_TRUE(stm.good());
string actual;
std::getline(stm, actual);
EXPECT_EQ("hello world", actual);
std::getline(stm, actual);
EXPECT_EQ("you are beautiful", actual);
std::getline(stm, actual);
EXPECT_EQ("", actual);
}
{
std::ifstream stm(path);
EXPECT_FALSE(stm.good());
}
}
TEST_F(RunfilesTest, IsAbsolute) {
EXPECT_FALSE(TestOnly_IsAbsolute("foo"));
EXPECT_FALSE(TestOnly_IsAbsolute("foo/bar"));
EXPECT_FALSE(TestOnly_IsAbsolute("\\foo"));
EXPECT_TRUE(TestOnly_IsAbsolute("c:\\foo"));
EXPECT_TRUE(TestOnly_IsAbsolute("c:/foo"));
EXPECT_TRUE(TestOnly_IsAbsolute("/foo"));
EXPECT_TRUE(TestOnly_IsAbsolute("x:\\foo"));
EXPECT_FALSE(TestOnly_IsAbsolute("::\\foo"));
EXPECT_FALSE(TestOnly_IsAbsolute("x\\foo"));
EXPECT_FALSE(TestOnly_IsAbsolute("x:"));
EXPECT_TRUE(TestOnly_IsAbsolute("x:\\"));
}
} // namespace
} // namespace runfiles
} // namespace bazel