254 lines
7.5 KiB
C++
254 lines
7.5 KiB
C++
/*
|
|
* Copyright 2004 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.
|
|
*/
|
|
|
|
#ifndef WEBRTC_BASE_FILEUTILS_MOCK_H_
|
|
#define WEBRTC_BASE_FILEUTILS_MOCK_H_
|
|
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "webrtc/base/fileutils.h"
|
|
#include "webrtc/base/gunit.h"
|
|
#include "webrtc/base/pathutils.h"
|
|
#include "webrtc/base/stream.h"
|
|
|
|
namespace rtc {
|
|
|
|
class FakeFileStream : public FileStream {
|
|
public:
|
|
explicit FakeFileStream(const std::string & contents) :
|
|
string_stream_(contents)
|
|
{}
|
|
|
|
virtual StreamResult Read(void* buffer, size_t buffer_len,
|
|
size_t* read, int* error) {
|
|
return string_stream_.Read(buffer, buffer_len, read, error);
|
|
}
|
|
|
|
virtual void Close() {
|
|
return string_stream_.Close();
|
|
}
|
|
virtual bool GetSize(size_t* size) const {
|
|
return string_stream_.GetSize(size);
|
|
}
|
|
|
|
private:
|
|
StringStream string_stream_;
|
|
};
|
|
|
|
class FakeDirectoryIterator : public DirectoryIterator {
|
|
public:
|
|
typedef std::pair<std::string, std::string> File;
|
|
|
|
/*
|
|
* files should be sorted by directory
|
|
* put '/' at the end of file if you want it to be a directory
|
|
*
|
|
* Sample list:
|
|
* /var/dir/file1
|
|
* /var/dir/file2
|
|
* /var/dir/subdir1/
|
|
* /var/dir/subdir2/
|
|
* /var/dir2/file2
|
|
* /var/dir3/
|
|
*
|
|
* you can call Iterate for any path: /var, /var/dir, /var/dir2
|
|
* unrelated files will be ignored
|
|
*/
|
|
explicit FakeDirectoryIterator(const std::vector<File>& all_files) :
|
|
all_files_(all_files) {}
|
|
|
|
virtual bool Iterate(const Pathname& path) {
|
|
path_iterator_ = all_files_.begin();
|
|
path_ = path.pathname();
|
|
|
|
// make sure path ends end with '/'
|
|
if (path_.rfind(Pathname::DefaultFolderDelimiter()) != path_.size() - 1)
|
|
path_ += Pathname::DefaultFolderDelimiter();
|
|
|
|
return FakeDirectoryIterator::Search(std::string(""));
|
|
}
|
|
|
|
virtual bool Next() {
|
|
std::string current_name = Name();
|
|
path_iterator_++;
|
|
return FakeDirectoryIterator::Search(current_name);
|
|
}
|
|
|
|
bool Search(const std::string& current_name) {
|
|
for (; path_iterator_ != all_files_.end(); path_iterator_++) {
|
|
if (path_iterator_->first.find(path_) == 0
|
|
&& Name().compare(current_name) != 0) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
virtual bool IsDirectory() const {
|
|
std::string sub_path = path_iterator_->first;
|
|
|
|
return std::string::npos !=
|
|
sub_path.find(Pathname::DefaultFolderDelimiter(), path_.size());
|
|
}
|
|
|
|
virtual std::string Name() const {
|
|
std::string sub_path = path_iterator_->first;
|
|
|
|
// path - top level path (ex. /var/lib)
|
|
// sub_path - subpath under top level path (ex. /var/lib/dir/dir/file )
|
|
// find shortest non-trivial common path. (ex. /var/lib/dir)
|
|
size_t start = path_.size();
|
|
size_t end = sub_path.find(Pathname::DefaultFolderDelimiter(), start);
|
|
|
|
if (end != std::string::npos) {
|
|
return sub_path.substr(start, end - start);
|
|
} else {
|
|
return sub_path.substr(start);
|
|
}
|
|
}
|
|
|
|
private:
|
|
const std::vector<File> all_files_;
|
|
|
|
std::string path_;
|
|
std::vector<File>::const_iterator path_iterator_;
|
|
};
|
|
|
|
class FakeFileSystem : public FilesystemInterface {
|
|
public:
|
|
typedef std::pair<std::string, std::string> File;
|
|
|
|
explicit FakeFileSystem(const std::vector<File>& all_files) :
|
|
all_files_(all_files) {}
|
|
|
|
virtual DirectoryIterator *IterateDirectory() {
|
|
return new FakeDirectoryIterator(all_files_);
|
|
}
|
|
|
|
virtual FileStream * OpenFile(
|
|
const Pathname &filename,
|
|
const std::string &mode) {
|
|
std::vector<File>::const_iterator i_files = all_files_.begin();
|
|
std::string path = filename.pathname();
|
|
|
|
for (; i_files != all_files_.end(); i_files++) {
|
|
if (i_files->first.compare(path) == 0) {
|
|
return new FakeFileStream(i_files->second);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool CreatePrivateFile(const Pathname &filename) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool DeleteFile(const Pathname &filename) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool DeleteEmptyFolder(const Pathname &folder) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool DeleteFolderContents(const Pathname &folder) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool DeleteFolderAndContents(const Pathname &folder) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool CreateFolder(const Pathname &pathname) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool MoveFolder(const Pathname &old_path, const Pathname &new_path) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool MoveFile(const Pathname &old_path, const Pathname &new_path) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool CopyFile(const Pathname &old_path, const Pathname &new_path) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool IsFolder(const Pathname &pathname) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool IsFile(const Pathname &pathname) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool IsAbsent(const Pathname &pathname) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool IsTemporaryPath(const Pathname &pathname) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool GetTemporaryFolder(Pathname &path, bool create,
|
|
const std::string *append) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
std::string TempFilename(const Pathname &dir, const std::string &prefix) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return std::string();
|
|
}
|
|
bool GetFileSize(const Pathname &path, size_t *size) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool GetFileTime(const Pathname &path, FileTimeType which,
|
|
time_t* time) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool GetAppPathname(Pathname *path) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool GetAppDataFolder(Pathname *path, bool per_user) {
|
|
EXPECT_TRUE(per_user) << "Unsupported operation";
|
|
#if defined(WEBRTC_WIN)
|
|
path->SetPathname("c:\\Users\\test_user", "");
|
|
#else
|
|
path->SetPathname("/home/user/test_user", "");
|
|
#endif
|
|
return true;
|
|
}
|
|
bool GetAppTempFolder(Pathname *path) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
bool GetDiskFreeSpace(const Pathname& path, int64_t* freebytes) {
|
|
EXPECT_TRUE(false) << "Unsupported operation";
|
|
return false;
|
|
}
|
|
Pathname GetCurrentDirectory() {
|
|
return Pathname();
|
|
}
|
|
|
|
private:
|
|
const std::vector<File> all_files_;
|
|
};
|
|
} // namespace rtc
|
|
|
|
#endif // WEBRTC_BASE_FILEUTILS_MOCK_H_
|