blob: a500a07743c76959ac74a4f7f13097da9cd32589 [file] [log] [blame]
/*
* Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "testsupport/fileutils.h"
#include <cstdio>
#include <list>
#include <string>
#include "gtest/gtest.h"
#ifdef WIN32
static const char* kPathDelimiter = "\\";
#else
static const char* kPathDelimiter = "/";
#endif
static const std::string kDummyDir = "file_utils_unittest_dummy_dir";
static const std::string kResourcesDir = "resources";
static const std::string kTestName = "fileutils_unittest";
static const std::string kExtension = "tmp";
typedef std::list<std::string> FileList;
namespace webrtc {
// Test fixture to restore the working directory between each test, since some
// of them change it with chdir during execution (not restored by the
// gtest framework).
class FileUtilsTest : public testing::Test {
protected:
FileUtilsTest() {
}
virtual ~FileUtilsTest() {}
// Runs before the first test
static void SetUpTestCase() {
original_working_dir_ = webrtc::test::WorkingDir();
std::string resources_path = original_working_dir_ + kPathDelimiter +
kResourcesDir + kPathDelimiter;
webrtc::test::CreateDirectory(resources_path);
files_.push_back(resources_path + kTestName + "." + kExtension);
files_.push_back(resources_path + kTestName + "_32." + kExtension);
files_.push_back(resources_path + kTestName + "_64." + kExtension);
files_.push_back(resources_path + kTestName + "_linux." + kExtension);
files_.push_back(resources_path + kTestName + "_mac." + kExtension);
files_.push_back(resources_path + kTestName + "_win." + kExtension);
files_.push_back(resources_path + kTestName + "_linux_32." + kExtension);
files_.push_back(resources_path + kTestName + "_mac_32." + kExtension);
files_.push_back(resources_path + kTestName + "_win_32." + kExtension);
files_.push_back(resources_path + kTestName + "_linux_64." + kExtension);
files_.push_back(resources_path + kTestName + "_mac_64." + kExtension);
files_.push_back(resources_path + kTestName + "_win_64." + kExtension);
// Now that the resources dir exists, write some empty test files into it.
for (FileList::iterator file_it = files_.begin();
file_it != files_.end(); ++file_it) {
FILE* file = fopen(file_it->c_str(), "wb");
ASSERT_TRUE(file != NULL) << "Failed to write file: " << file_it->c_str();
ASSERT_GT(fprintf(file, "%s", "Dummy data"), 0);
fclose(file);
}
// Create a dummy subdir that can be chdir'ed into for testing purposes.
empty_dummy_dir_ = original_working_dir_ + kPathDelimiter + kDummyDir;
webrtc::test::CreateDirectory(empty_dummy_dir_);
}
static void TearDownTestCase() {
// Clean up all resource files written
for (FileList::iterator file_it = files_.begin();
file_it != files_.end(); ++file_it) {
remove(file_it->c_str());
}
std::remove(empty_dummy_dir_.c_str());
}
void SetUp() {
ASSERT_EQ(chdir(original_working_dir_.c_str()), 0);
}
void TearDown() {
ASSERT_EQ(chdir(original_working_dir_.c_str()), 0);
}
protected:
static FileList files_;
static std::string empty_dummy_dir_;
private:
static std::string original_working_dir_;
};
FileList FileUtilsTest::files_;
std::string FileUtilsTest::original_working_dir_ = "";
std::string FileUtilsTest::empty_dummy_dir_ = "";
// Tests that the project root path is returned for the default working
// directory that is automatically set when the test executable is launched.
// The test is not fully testing the implementation, since we cannot be sure
// of where the executable was launched from.
// The test will fail if the top level directory is not named "trunk".
TEST_F(FileUtilsTest, ProjectRootPathFromUnchangedWorkingDir) {
std::string path = webrtc::test::ProjectRootPath();
std::string expected_end = "trunk";
expected_end = kPathDelimiter + expected_end + kPathDelimiter;
ASSERT_EQ(path.length() - expected_end.length(), path.find(expected_end));
}
// Similar to the above test, but for the output dir
TEST_F(FileUtilsTest, OutputPathFromUnchangedWorkingDir) {
std::string path = webrtc::test::OutputPath();
std::string expected_end = "out";
expected_end = kPathDelimiter + expected_end + kPathDelimiter;
ASSERT_EQ(path.length() - expected_end.length(), path.find(expected_end));
}
// Tests setting the current working directory to a directory three levels
// deeper from the current one. Then testing that the project path returned
// is still the same, when the function under test is called again.
TEST_F(FileUtilsTest, ProjectRootPathFromDeeperWorkingDir) {
std::string path = webrtc::test::ProjectRootPath();
std::string original_working_dir = path; // This is the correct project root
// Change to a subdirectory path.
ASSERT_EQ(0, chdir(empty_dummy_dir_.c_str()));
ASSERT_EQ(original_working_dir, webrtc::test::ProjectRootPath());
}
// Similar to the above test, but for the output dir
TEST_F(FileUtilsTest, OutputPathFromDeeperWorkingDir) {
std::string path = webrtc::test::OutputPath();
std::string original_working_dir = path;
ASSERT_EQ(0, chdir(empty_dummy_dir_.c_str()));
ASSERT_EQ(original_working_dir, webrtc::test::OutputPath());
}
// Tests with current working directory set to a directory higher up in the
// directory tree than the project root dir. This case shall return a specified
// error string as a directory (which will be an invalid path).
TEST_F(FileUtilsTest, ProjectRootPathFromRootWorkingDir) {
// Change current working dir to the root of the current file system
// (this will always be "above" our project root dir).
ASSERT_EQ(0, chdir(kPathDelimiter));
ASSERT_EQ(webrtc::test::kCannotFindProjectRootDir,
webrtc::test::ProjectRootPath());
}
// Similar to the above test, but for the output dir
TEST_F(FileUtilsTest, OutputPathFromRootWorkingDir) {
ASSERT_EQ(0, chdir(kPathDelimiter));
ASSERT_EQ("./", webrtc::test::OutputPath());
}
// Only tests that the code executes
TEST_F(FileUtilsTest, CreateDirectory) {
std::string directory = "fileutils-unittest-empty-dir";
// Make sure it's removed if a previous test has failed:
std::remove(directory.c_str());
ASSERT_TRUE(webrtc::test::CreateDirectory(directory));
std::remove(directory.c_str());
}
TEST_F(FileUtilsTest, WorkingDirReturnsValue) {
// Hard to cover all platforms. Just test that it returns something without
// crashing:
std::string working_dir = webrtc::test::WorkingDir();
ASSERT_GT(working_dir.length(), 0u);
}
// Due to multiple platforms, it is hard to make a complete test for
// ResourcePath. Manual testing has been performed by removing files and
// verified the result confirms with the specified documentation for the
// function.
TEST_F(FileUtilsTest, ResourcePathReturnsValue) {
std::string resource = webrtc::test::ResourcePath(kTestName, kExtension);
ASSERT_GT(resource.find(kTestName), 0u);
ASSERT_GT(resource.find(kExtension), 0u);
ASSERT_EQ(0, chdir(kPathDelimiter));
ASSERT_EQ("./", webrtc::test::OutputPath());
}
TEST_F(FileUtilsTest, GetFileSizeExistingFile) {
ASSERT_GT(webrtc::test::GetFileSize(files_.front()), 0u);
}
TEST_F(FileUtilsTest, GetFileSizeNonExistingFile) {
ASSERT_EQ(0u, webrtc::test::GetFileSize("non-existing-file.tmp"));
}
} // namespace webrtc