src/third_party/libjingle/source/talk/base/fileutils_mock.h

   1 /*
   2  * libjingle
   3  * Copyright 2004--2011, Google Inc.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  *  1. Redistributions of source code must retain the above copyright notice,
   9  *     this list of conditions and the following disclaimer.
  10  *  2. Redistributions in binary form must reproduce the above copyright notice,
  11  *     this list of conditions and the following disclaimer in the documentation
  12  *     and/or other materials provided with the distribution.
  13  *  3. The name of the author may not be used to endorse or promote products
  14  *     derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #ifndef TALK_BASE_FILEUTILS_MOCK_H_
  29 #define TALK_BASE_FILEUTILS_MOCK_H_
  30
  31 #include <string>
  32 #include <utility>
  33 #include <vector>
  34
  35 #include "talk/base/fileutils.h"
  36 #include "talk/base/gunit.h"
  37 #include "talk/base/pathutils.h"
  38 #include "talk/base/stream.h"
  39
  40 namespace talk_base {
  41
  42 class FakeFileStream : public FileStream {
  43   public:
  44     explicit FakeFileStream(const std::string & contents) :
  45       string_stream_(contents)
  46     {}
  47
  48     virtual StreamResult Read(void* buffer, size_t buffer_len,
  49                               size_t* read, int* error) {
  50       return string_stream_.Read(buffer, buffer_len, read, error);
  51     }
  52
  53     virtual void Close() {
  54       return string_stream_.Close();
  55     }
  56     virtual bool GetSize(size_t* size) const {
  57       return string_stream_.GetSize(size);
  58     }
  59
  60   private:
  61     StringStream string_stream_;
  62 };
  63
  64 class FakeDirectoryIterator : public DirectoryIterator {
  65   public:
  66     typedef std::pair<std::string, std::string> File;
  67
  68     /*
  69      * files should be sorted by directory
  70      * put '/' at the end of file if you want it to be a directory
  71      *
  72      * Sample list:
  73      *  /var/dir/file1
  74      *  /var/dir/file2
  75      *  /var/dir/subdir1/
  76      *  /var/dir/subdir2/
  77      *  /var/dir2/file2
  78      *  /var/dir3/
  79      *
  80      *  you can call Iterate for any path: /var, /var/dir, /var/dir2
  81      *  unrelated files will be ignored
  82      */
  83     explicit FakeDirectoryIterator(const std::vector<File>& all_files) :
  84       all_files_(all_files) {}
  85
  86     virtual bool Iterate(const Pathname& path) {
  87       path_iterator_ = all_files_.begin();
  88       path_ = path.pathname();
  89
  90       // make sure path ends end with '/'
  91       if (path_.rfind(Pathname::DefaultFolderDelimiter()) != path_.size() - 1)
  92         path_ += Pathname::DefaultFolderDelimiter();
  93
  94       return  FakeDirectoryIterator::Search(std::string(""));
  95     }
  96
  97     virtual bool Next() {
  98       std::string current_name = Name();
  99       path_iterator_++;
 100       return FakeDirectoryIterator::Search(current_name);
 101     }
 102
 103     bool Search(const std::string& current_name) {
 104       for (; path_iterator_ != all_files_.end(); path_iterator_++) {
 105         if (path_iterator_->first.find(path_) == 0
 106             && Name().compare(current_name) != 0) {
 107           return true;
 108         }
 109       }
 110
 111       return false;
 112     }
 113
 114     virtual bool IsDirectory() const {
 115       std::string sub_path = path_iterator_->first;
 116
 117       return std::string::npos !=
 118         sub_path.find(Pathname::DefaultFolderDelimiter(), path_.size());
 119     }
 120
 121     virtual std::string Name() const {
 122       std::string sub_path = path_iterator_->first;
 123
 124       // path     - top level path  (ex. /var/lib)
 125       // sub_path - subpath under top level path (ex. /var/lib/dir/dir/file )
 126       // find shortest non-trivial common path. (ex. /var/lib/dir)
 127       size_t start  = path_.size();
 128       size_t end    = sub_path.find(Pathname::DefaultFolderDelimiter(), start);
 129
 130       if (end != std::string::npos) {
 131         return sub_path.substr(start, end - start);
 132       } else {
 133         return sub_path.substr(start);
 134       }
 135     }
 136
 137   private:
 138     const std::vector<File> all_files_;
 139
 140     std::string path_;
 141     std::vector<File>::const_iterator path_iterator_;
 142 };
 143
 144 class FakeFileSystem : public FilesystemInterface {
 145   public:
 146     typedef std::pair<std::string, std::string> File;
 147
 148     explicit FakeFileSystem(const std::vector<File>& all_files) :
 149      all_files_(all_files) {}
 150
 151     virtual DirectoryIterator *IterateDirectory() {
 152      return new FakeDirectoryIterator(all_files_);
 153     }
 154
 155     virtual FileStream * OpenFile(
 156        const Pathname &filename,
 157        const std::string &mode) {
 158      std::vector<File>::const_iterator i_files = all_files_.begin();
 159      std::string path = filename.pathname();
 160
 161      for (; i_files != all_files_.end(); i_files++) {
 162        if (i_files->first.compare(path) == 0) {
 163          return new FakeFileStream(i_files->second);
 164        }
 165      }
 166
 167      return NULL;
 168     }
 169
 170     bool CreatePrivateFile(const Pathname &filename) {
 171       EXPECT_TRUE(false) << "Unsupported operation";
 172       return false;
 173     }
 174     bool DeleteFile(const Pathname &filename) {
 175       EXPECT_TRUE(false) << "Unsupported operation";
 176       return false;
 177     }
 178     bool DeleteEmptyFolder(const Pathname &folder) {
 179       EXPECT_TRUE(false) << "Unsupported operation";
 180       return false;
 181     }
 182     bool DeleteFolderContents(const Pathname &folder) {
 183       EXPECT_TRUE(false) << "Unsupported operation";
 184       return false;
 185     }
 186     bool DeleteFolderAndContents(const Pathname &folder) {
 187       EXPECT_TRUE(false) << "Unsupported operation";
 188       return false;
 189     }
 190     bool CreateFolder(const Pathname &pathname) {
 191       EXPECT_TRUE(false) << "Unsupported operation";
 192       return false;
 193     }
 194     bool MoveFolder(const Pathname &old_path, const Pathname &new_path) {
 195       EXPECT_TRUE(false) << "Unsupported operation";
 196       return false;
 197     }
 198     bool MoveFile(const Pathname &old_path, const Pathname &new_path) {
 199       EXPECT_TRUE(false) << "Unsupported operation";
 200       return false;
 201     }
 202     bool CopyFile(const Pathname &old_path, const Pathname &new_path) {
 203       EXPECT_TRUE(false) << "Unsupported operation";
 204       return false;
 205     }
 206     bool IsFolder(const Pathname &pathname) {
 207       EXPECT_TRUE(false) << "Unsupported operation";
 208       return false;
 209     }
 210     bool IsFile(const Pathname &pathname) {
 211       EXPECT_TRUE(false) << "Unsupported operation";
 212       return false;
 213     }
 214     bool IsAbsent(const Pathname &pathname) {
 215       EXPECT_TRUE(false) << "Unsupported operation";
 216       return false;
 217     }
 218     bool IsTemporaryPath(const Pathname &pathname) {
 219       EXPECT_TRUE(false) << "Unsupported operation";
 220       return false;
 221     }
 222     bool GetTemporaryFolder(Pathname &path, bool create,
 223                             const std::string *append) {
 224       EXPECT_TRUE(false) << "Unsupported operation";
 225       return false;
 226     }
 227     std::string TempFilename(const Pathname &dir, const std::string &prefix) {
 228       EXPECT_TRUE(false) << "Unsupported operation";
 229       return std::string();
 230     }
 231     bool GetFileSize(const Pathname &path, size_t *size) {
 232       EXPECT_TRUE(false) << "Unsupported operation";
 233       return false;
 234     }
 235     bool GetFileTime(const Pathname &path, FileTimeType which,
 236                      time_t* time) {
 237       EXPECT_TRUE(false) << "Unsupported operation";
 238       return false;
 239     }
 240     bool GetAppPathname(Pathname *path) {
 241       EXPECT_TRUE(false) << "Unsupported operation";
 242       return false;
 243     }
 244     bool GetAppDataFolder(Pathname *path, bool per_user) {
 245       EXPECT_TRUE(per_user) << "Unsupported operation";
 246 #ifdef WIN32
 247       path->SetPathname("c:\\Users\\test_user", "");
 248 #else
 249       path->SetPathname("/home/user/test_user", "");
 250 #endif
 251       return true;
 252     }
 253     bool GetAppTempFolder(Pathname *path) {
 254       EXPECT_TRUE(false) << "Unsupported operation";
 255       return false;
 256     }
 257     bool GetDiskFreeSpace(const Pathname &path, int64 *freebytes) {
 258       EXPECT_TRUE(false) << "Unsupported operation";
 259       return false;
 260     }
 261     Pathname GetCurrentDirectory() {
 262       return Pathname();
 263     }
 264
 265   private:
 266     const std::vector<File> all_files_;
 267 };
 268 }  // namespace talk_base
 269
 270 #endif  // TALK_BASE_FILEUTILS_MOCK_H_