| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2008, Google Inc. | |
| 2 // All rights reserved. | |
| 3 // | |
| 4 // Redistribution and use in source and binary forms, with or without | |
| 5 // modification, are permitted provided that the following conditions are | |
| 6 // met: | |
| 7 // | |
| 8 // * Redistributions of source code must retain the above copyright | |
| 9 // notice, this list of conditions and the following disclaimer. | |
| 10 // * Redistributions in binary form must reproduce the above | |
| 11 // copyright notice, this list of conditions and the following disclaimer | |
| 12 // in the documentation and/or other materials provided with the | |
| 13 // distribution. | |
| 14 // * Neither the name of Google Inc. nor the names of its | |
| 15 // contributors may be used to endorse or promote products derived from | |
| 16 // this software without specific prior written permission. | |
| 17 // | |
| 18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| 19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| 20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| 21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| 22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| 24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| 25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| 26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| 28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 29 // | |
| 30 // Authors: keith.ray@gmail.com (Keith Ray) | |
| 31 | |
| 32 #include <gtest/internal/gtest-filepath.h> | |
| 33 #include <gtest/internal/gtest-port.h> | |
| 34 | |
| 35 #include <stdlib.h> | |
| 36 | |
| 37 #if GTEST_OS_WINDOWS_MOBILE | |
| 38 #include <windows.h> | |
| 39 #elif GTEST_OS_WINDOWS | |
| 40 #include <direct.h> | |
| 41 #include <io.h> | |
| 42 #elif GTEST_OS_SYMBIAN | |
| 43 // Symbian OpenC has PATH_MAX in sys/syslimits.h | |
| 44 #include <sys/syslimits.h> | |
| 45 #else | |
| 46 #include <limits.h> | |
| 47 #include <climits> // Some Linux distributions define PATH_MAX here. | |
| 48 #endif // GTEST_OS_WINDOWS_MOBILE | |
| 49 | |
| 50 #if GTEST_OS_WINDOWS | |
| 51 #define GTEST_PATH_MAX_ _MAX_PATH | |
| 52 #elif defined(PATH_MAX) | |
| 53 #define GTEST_PATH_MAX_ PATH_MAX | |
| 54 #elif defined(_XOPEN_PATH_MAX) | |
| 55 #define GTEST_PATH_MAX_ _XOPEN_PATH_MAX | |
| 56 #else | |
| 57 #define GTEST_PATH_MAX_ _POSIX_PATH_MAX | |
| 58 #endif // GTEST_OS_WINDOWS | |
| 59 | |
| 60 #include <gtest/internal/gtest-string.h> | |
| 61 | |
| 62 namespace testing { | |
| 63 namespace internal { | |
| 64 | |
| 65 #if GTEST_OS_WINDOWS | |
| 66 const char kPathSeparator = '\\'; | |
| 67 const char kPathSeparatorString[] = "\\"; | |
| 68 #if GTEST_OS_WINDOWS_MOBILE | |
| 69 // Windows CE doesn't have a current directory. You should not use | |
| 70 // the current directory in tests on Windows CE, but this at least | |
| 71 // provides a reasonable fallback. | |
| 72 const char kCurrentDirectoryString[] = "\\"; | |
| 73 // Windows CE doesn't define INVALID_FILE_ATTRIBUTES | |
| 74 const DWORD kInvalidFileAttributes = 0xffffffff; | |
| 75 #else | |
| 76 const char kCurrentDirectoryString[] = ".\\"; | |
| 77 #endif // GTEST_OS_WINDOWS_MOBILE | |
| 78 #else | |
| 79 const char kPathSeparator = '/'; | |
| 80 const char kPathSeparatorString[] = "/"; | |
| 81 const char kCurrentDirectoryString[] = "./"; | |
| 82 #endif // GTEST_OS_WINDOWS | |
| 83 | |
| 84 // Returns the current working directory, or "" if unsuccessful. | |
| 85 FilePath FilePath::GetCurrentDir() { | |
| 86 #if GTEST_OS_WINDOWS_MOBILE | |
| 87 // Windows CE doesn't have a current directory, so we just return | |
| 88 // something reasonable. | |
| 89 return FilePath(kCurrentDirectoryString); | |
| 90 #elif GTEST_OS_WINDOWS | |
| 91 char cwd[GTEST_PATH_MAX_ + 1] = { '\0' }; | |
| 92 return FilePath(_getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd); | |
| 93 #else | |
| 94 char cwd[GTEST_PATH_MAX_ + 1] = { '\0' }; | |
| 95 return FilePath(getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd); | |
| 96 #endif // GTEST_OS_WINDOWS_MOBILE | |
| 97 } | |
| 98 | |
| 99 // Returns a copy of the FilePath with the case-insensitive extension removed. | |
| 100 // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns | |
| 101 // FilePath("dir/file"). If a case-insensitive extension is not | |
| 102 // found, returns a copy of the original FilePath. | |
| 103 FilePath FilePath::RemoveExtension(const char* extension) const { | |
| 104 String dot_extension(String::Format(".%s", extension)); | |
| 105 if (pathname_.EndsWithCaseInsensitive(dot_extension.c_str())) { | |
| 106 return FilePath(String(pathname_.c_str(), pathname_.length() - 4)); | |
| 107 } | |
| 108 return *this; | |
| 109 } | |
| 110 | |
| 111 // Returns a copy of the FilePath with the directory part removed. | |
| 112 // Example: FilePath("path/to/file").RemoveDirectoryName() returns | |
| 113 // FilePath("file"). If there is no directory part ("just_a_file"), it returns | |
| 114 // the FilePath unmodified. If there is no file part ("just_a_dir/") it | |
| 115 // returns an empty FilePath (""). | |
| 116 // On Windows platform, '\' is the path separator, otherwise it is '/'. | |
| 117 FilePath FilePath::RemoveDirectoryName() const { | |
| 118 const char* const last_sep = strrchr(c_str(), kPathSeparator); | |
| 119 return last_sep ? FilePath(String(last_sep + 1)) : *this; | |
| 120 } | |
| 121 | |
| 122 // RemoveFileName returns the directory path with the filename removed. | |
| 123 // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/". | |
| 124 // If the FilePath is "a_file" or "/a_file", RemoveFileName returns | |
| 125 // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does | |
| 126 // not have a file, like "just/a/dir/", it returns the FilePath unmodified. | |
| 127 // On Windows platform, '\' is the path separator, otherwise it is '/'. | |
| 128 FilePath FilePath::RemoveFileName() const { | |
| 129 const char* const last_sep = strrchr(c_str(), kPathSeparator); | |
| 130 String dir; | |
| 131 if (last_sep) { | |
| 132 dir = String(c_str(), last_sep + 1 - c_str()); | |
| 133 } else { | |
| 134 dir = kCurrentDirectoryString; | |
| 135 } | |
| 136 return FilePath(dir); | |
| 137 } | |
| 138 | |
| 139 // Helper functions for naming files in a directory for xml output. | |
| 140 | |
| 141 // Given directory = "dir", base_name = "test", number = 0, | |
| 142 // extension = "xml", returns "dir/test.xml". If number is greater | |
| 143 // than zero (e.g., 12), returns "dir/test_12.xml". | |
| 144 // On Windows platform, uses \ as the separator rather than /. | |
| 145 FilePath FilePath::MakeFileName(const FilePath& directory, | |
| 146 const FilePath& base_name, | |
| 147 int number, | |
| 148 const char* extension) { | |
| 149 String file; | |
| 150 if (number == 0) { | |
| 151 file = String::Format("%s.%s", base_name.c_str(), extension); | |
| 152 } else { | |
| 153 file = String::Format("%s_%d.%s", base_name.c_str(), number, extension); | |
| 154 } | |
| 155 return ConcatPaths(directory, FilePath(file)); | |
| 156 } | |
| 157 | |
| 158 // Given directory = "dir", relative_path = "test.xml", returns "dir/test.xml". | |
| 159 // On Windows, uses \ as the separator rather than /. | |
| 160 FilePath FilePath::ConcatPaths(const FilePath& directory, | |
| 161 const FilePath& relative_path) { | |
| 162 if (directory.IsEmpty()) | |
| 163 return relative_path; | |
| 164 const FilePath dir(directory.RemoveTrailingPathSeparator()); | |
| 165 return FilePath(String::Format("%s%c%s", dir.c_str(), kPathSeparator, | |
| 166 relative_path.c_str())); | |
| 167 } | |
| 168 | |
| 169 // Returns true if pathname describes something findable in the file-system, | |
| 170 // either a file, directory, or whatever. | |
| 171 bool FilePath::FileOrDirectoryExists() const { | |
| 172 #if GTEST_OS_WINDOWS_MOBILE | |
| 173 LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str()); | |
| 174 const DWORD attributes = GetFileAttributes(unicode); | |
| 175 delete [] unicode; | |
| 176 return attributes != kInvalidFileAttributes; | |
| 177 #else | |
| 178 posix::StatStruct file_stat; | |
| 179 return posix::Stat(pathname_.c_str(), &file_stat) == 0; | |
| 180 #endif // GTEST_OS_WINDOWS_MOBILE | |
| 181 } | |
| 182 | |
| 183 // Returns true if pathname describes a directory in the file-system | |
| 184 // that exists. | |
| 185 bool FilePath::DirectoryExists() const { | |
| 186 bool result = false; | |
| 187 #if GTEST_OS_WINDOWS | |
| 188 // Don't strip off trailing separator if path is a root directory on | |
| 189 // Windows (like "C:\\"). | |
| 190 const FilePath& path(IsRootDirectory() ? *this : | |
| 191 RemoveTrailingPathSeparator()); | |
| 192 #else | |
| 193 const FilePath& path(*this); | |
| 194 #endif | |
| 195 | |
| 196 #if GTEST_OS_WINDOWS_MOBILE | |
| 197 LPCWSTR unicode = String::AnsiToUtf16(path.c_str()); | |
| 198 const DWORD attributes = GetFileAttributes(unicode); | |
| 199 delete [] unicode; | |
| 200 if ((attributes != kInvalidFileAttributes) && | |
| 201 (attributes & FILE_ATTRIBUTE_DIRECTORY)) { | |
| 202 result = true; | |
| 203 } | |
| 204 #else | |
| 205 posix::StatStruct file_stat; | |
| 206 result = posix::Stat(path.c_str(), &file_stat) == 0 && | |
| 207 posix::IsDir(file_stat); | |
| 208 #endif // GTEST_OS_WINDOWS_MOBILE | |
| 209 | |
| 210 return result; | |
| 211 } | |
| 212 | |
| 213 // Returns true if pathname describes a root directory. (Windows has one | |
| 214 // root directory per disk drive.) | |
| 215 bool FilePath::IsRootDirectory() const { | |
| 216 #if GTEST_OS_WINDOWS | |
| 217 // TODO(wan@google.com): on Windows a network share like | |
| 218 // \\server\share can be a root directory, although it cannot be the | |
| 219 // current directory. Handle this properly. | |
| 220 return pathname_.length() == 3 && IsAbsolutePath(); | |
| 221 #else | |
| 222 return pathname_ == kPathSeparatorString; | |
| 223 #endif | |
| 224 } | |
| 225 | |
| 226 // Returns true if pathname describes an absolute path. | |
| 227 bool FilePath::IsAbsolutePath() const { | |
| 228 const char* const name = pathname_.c_str(); | |
| 229 #if GTEST_OS_WINDOWS | |
| 230 return pathname_.length() >= 3 && | |
| 231 ((name[0] >= 'a' && name[0] <= 'z') || | |
| 232 (name[0] >= 'A' && name[0] <= 'Z')) && | |
| 233 name[1] == ':' && | |
| 234 name[2] == kPathSeparator; | |
| 235 #else | |
| 236 return name[0] == kPathSeparator; | |
| 237 #endif | |
| 238 } | |
| 239 | |
| 240 // Returns a pathname for a file that does not currently exist. The pathname | |
| 241 // will be directory/base_name.extension or | |
| 242 // directory/base_name_<number>.extension if directory/base_name.extension | |
| 243 // already exists. The number will be incremented until a pathname is found | |
| 244 // that does not already exist. | |
| 245 // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'. | |
| 246 // There could be a race condition if two or more processes are calling this | |
| 247 // function at the same time -- they could both pick the same filename. | |
| 248 FilePath FilePath::GenerateUniqueFileName(const FilePath& directory, | |
| 249 const FilePath& base_name, | |
| 250 const char* extension) { | |
| 251 FilePath full_pathname; | |
| 252 int number = 0; | |
| 253 do { | |
| 254 full_pathname.Set(MakeFileName(directory, base_name, number++, extension)); | |
| 255 } while (full_pathname.FileOrDirectoryExists()); | |
| 256 return full_pathname; | |
| 257 } | |
| 258 | |
| 259 // Returns true if FilePath ends with a path separator, which indicates that | |
| 260 // it is intended to represent a directory. Returns false otherwise. | |
| 261 // This does NOT check that a directory (or file) actually exists. | |
| 262 bool FilePath::IsDirectory() const { | |
| 263 return pathname_.EndsWith(kPathSeparatorString); | |
| 264 } | |
| 265 | |
| 266 // Create directories so that path exists. Returns true if successful or if | |
| 267 // the directories already exist; returns false if unable to create directories | |
| 268 // for any reason. | |
| 269 bool FilePath::CreateDirectoriesRecursively() const { | |
| 270 if (!this->IsDirectory()) { | |
| 271 return false; | |
| 272 } | |
| 273 | |
| 274 if (pathname_.length() == 0 || this->DirectoryExists()) { | |
| 275 return true; | |
| 276 } | |
| 277 | |
| 278 const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName()); | |
| 279 return parent.CreateDirectoriesRecursively() && this->CreateFolder(); | |
| 280 } | |
| 281 | |
| 282 // Create the directory so that path exists. Returns true if successful or | |
| 283 // if the directory already exists; returns false if unable to create the | |
| 284 // directory for any reason, including if the parent directory does not | |
| 285 // exist. Not named "CreateDirectory" because that's a macro on Windows. | |
| 286 bool FilePath::CreateFolder() const { | |
| 287 #if GTEST_OS_WINDOWS_MOBILE | |
| 288 FilePath removed_sep(this->RemoveTrailingPathSeparator()); | |
| 289 LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str()); | |
| 290 int result = CreateDirectory(unicode, NULL) ? 0 : -1; | |
| 291 delete [] unicode; | |
| 292 #elif GTEST_OS_WINDOWS | |
| 293 int result = _mkdir(pathname_.c_str()); | |
| 294 #else | |
| 295 int result = mkdir(pathname_.c_str(), 0777); | |
| 296 #endif // GTEST_OS_WINDOWS_MOBILE | |
| 297 | |
| 298 if (result == -1) { | |
| 299 return this->DirectoryExists(); // An error is OK if the directory exists. | |
| 300 } | |
| 301 return true; // No error. | |
| 302 } | |
| 303 | |
| 304 // If input name has a trailing separator character, remove it and return the | |
| 305 // name, otherwise return the name string unmodified. | |
| 306 // On Windows platform, uses \ as the separator, other platforms use /. | |
| 307 FilePath FilePath::RemoveTrailingPathSeparator() const { | |
| 308 return pathname_.EndsWith(kPathSeparatorString) | |
| 309 ? FilePath(String(pathname_.c_str(), pathname_.length() - 1)) | |
| 310 : *this; | |
| 311 } | |
| 312 | |
| 313 // Normalize removes any redundant separators that might be in the pathname. | |
| 314 // For example, "bar///foo" becomes "bar/foo". Does not eliminate other | |
| 315 // redundancies that might be in a pathname involving "." or "..". | |
| 316 void FilePath::Normalize() { | |
| 317 if (pathname_.c_str() == NULL) { | |
| 318 pathname_ = ""; | |
| 319 return; | |
| 320 } | |
| 321 const char* src = pathname_.c_str(); | |
| 322 char* const dest = new char[pathname_.length() + 1]; | |
| 323 char* dest_ptr = dest; | |
| 324 memset(dest_ptr, 0, pathname_.length() + 1); | |
| 325 | |
| 326 while (*src != '\0') { | |
| 327 *dest_ptr++ = *src; | |
| 328 if (*src != kPathSeparator) | |
| 329 src++; | |
| 330 else | |
| 331 while (*src == kPathSeparator) | |
| 332 src++; | |
| 333 } | |
| 334 *dest_ptr = '\0'; | |
| 335 pathname_ = dest; | |
| 336 delete[] dest; | |
| 337 } | |
| 338 | |
| 339 } // namespace internal | |
| 340 } // namespace testing | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 624713003:
Keep only base/extractor.[cc|h]. (Closed)
Base URL: https://chromium.googlesource.com/external/omaha.git@master