gtest-filepath.h 9.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211
  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. // Google Test filepath utilities
  31. //
  32. // This header file declares classes and functions used internally by
  33. // Google Test. They are subject to change without notice.
  34. //
  35. // This file is #included in gtest/internal/gtest-internal.h.
  36. // Do not include this header file separately!
  37. // GOOGLETEST_CM0001 DO NOT DELETE
  38. #ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
  39. #define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
  40. #include "gtest/internal/gtest-string.h"
  41. GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
  42. /* class A needs to have dll-interface to be used by clients of class B */)
  43. namespace testing {
  44. namespace internal {
  45. // FilePath - a class for file and directory pathname manipulation which
  46. // handles platform-specific conventions (like the pathname separator).
  47. // Used for helper functions for naming files in a directory for xml output.
  48. // Except for Set methods, all methods are const or static, which provides an
  49. // "immutable value object" -- useful for peace of mind.
  50. // A FilePath with a value ending in a path separator ("like/this/") represents
  51. // a directory, otherwise it is assumed to represent a file. In either case,
  52. // it may or may not represent an actual file or directory in the file system.
  53. // Names are NOT checked for syntax correctness -- no checking for illegal
  54. // characters, malformed paths, etc.
  55. class GTEST_API_ FilePath {
  56. public:
  57. FilePath() : pathname_("") { }
  58. FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
  59. explicit FilePath(const std::string& pathname) : pathname_(pathname) {
  60. Normalize();
  61. }
  62. FilePath& operator=(const FilePath& rhs) {
  63. Set(rhs);
  64. return *this;
  65. }
  66. void Set(const FilePath& rhs) {
  67. pathname_ = rhs.pathname_;
  68. }
  69. const std::string& string() const { return pathname_; }
  70. const char* c_str() const { return pathname_.c_str(); }
  71. // Returns the current working directory, or "" if unsuccessful.
  72. static FilePath GetCurrentDir();
  73. // Given directory = "dir", base_name = "test", number = 0,
  74. // extension = "xml", returns "dir/test.xml". If number is greater
  75. // than zero (e.g., 12), returns "dir/test_12.xml".
  76. // On Windows platform, uses \ as the separator rather than /.
  77. static FilePath MakeFileName(const FilePath& directory,
  78. const FilePath& base_name,
  79. int number,
  80. const char* extension);
  81. // Given directory = "dir", relative_path = "test.xml",
  82. // returns "dir/test.xml".
  83. // On Windows, uses \ as the separator rather than /.
  84. static FilePath ConcatPaths(const FilePath& directory,
  85. const FilePath& relative_path);
  86. // Returns a pathname for a file that does not currently exist. The pathname
  87. // will be directory/base_name.extension or
  88. // directory/base_name_<number>.extension if directory/base_name.extension
  89. // already exists. The number will be incremented until a pathname is found
  90. // that does not already exist.
  91. // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
  92. // There could be a race condition if two or more processes are calling this
  93. // function at the same time -- they could both pick the same filename.
  94. static FilePath GenerateUniqueFileName(const FilePath& directory,
  95. const FilePath& base_name,
  96. const char* extension);
  97. // Returns true if and only if the path is "".
  98. bool IsEmpty() const { return pathname_.empty(); }
  99. // If input name has a trailing separator character, removes it and returns
  100. // the name, otherwise return the name string unmodified.
  101. // On Windows platform, uses \ as the separator, other platforms use /.
  102. FilePath RemoveTrailingPathSeparator() const;
  103. // Returns a copy of the FilePath with the directory part removed.
  104. // Example: FilePath("path/to/file").RemoveDirectoryName() returns
  105. // FilePath("file"). If there is no directory part ("just_a_file"), it returns
  106. // the FilePath unmodified. If there is no file part ("just_a_dir/") it
  107. // returns an empty FilePath ("").
  108. // On Windows platform, '\' is the path separator, otherwise it is '/'.
  109. FilePath RemoveDirectoryName() const;
  110. // RemoveFileName returns the directory path with the filename removed.
  111. // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
  112. // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
  113. // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
  114. // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
  115. // On Windows platform, '\' is the path separator, otherwise it is '/'.
  116. FilePath RemoveFileName() const;
  117. // Returns a copy of the FilePath with the case-insensitive extension removed.
  118. // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
  119. // FilePath("dir/file"). If a case-insensitive extension is not
  120. // found, returns a copy of the original FilePath.
  121. FilePath RemoveExtension(const char* extension) const;
  122. // Creates directories so that path exists. Returns true if successful or if
  123. // the directories already exist; returns false if unable to create
  124. // directories for any reason. Will also return false if the FilePath does
  125. // not represent a directory (that is, it doesn't end with a path separator).
  126. bool CreateDirectoriesRecursively() const;
  127. // Create the directory so that path exists. Returns true if successful or
  128. // if the directory already exists; returns false if unable to create the
  129. // directory for any reason, including if the parent directory does not
  130. // exist. Not named "CreateDirectory" because that's a macro on Windows.
  131. bool CreateFolder() const;
  132. // Returns true if FilePath describes something in the file-system,
  133. // either a file, directory, or whatever, and that something exists.
  134. bool FileOrDirectoryExists() const;
  135. // Returns true if pathname describes a directory in the file-system
  136. // that exists.
  137. bool DirectoryExists() const;
  138. // Returns true if FilePath ends with a path separator, which indicates that
  139. // it is intended to represent a directory. Returns false otherwise.
  140. // This does NOT check that a directory (or file) actually exists.
  141. bool IsDirectory() const;
  142. // Returns true if pathname describes a root directory. (Windows has one
  143. // root directory per disk drive.)
  144. bool IsRootDirectory() const;
  145. // Returns true if pathname describes an absolute path.
  146. bool IsAbsolutePath() const;
  147. private:
  148. // Replaces multiple consecutive separators with a single separator.
  149. // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
  150. // redundancies that might be in a pathname involving "." or "..".
  151. //
  152. // A pathname with multiple consecutive separators may occur either through
  153. // user error or as a result of some scripts or APIs that generate a pathname
  154. // with a trailing separator. On other platforms the same API or script
  155. // may NOT generate a pathname with a trailing "/". Then elsewhere that
  156. // pathname may have another "/" and pathname components added to it,
  157. // without checking for the separator already being there.
  158. // The script language and operating system may allow paths like "foo//bar"
  159. // but some of the functions in FilePath will not handle that correctly. In
  160. // particular, RemoveTrailingPathSeparator() only removes one separator, and
  161. // it is called in CreateDirectoriesRecursively() assuming that it will change
  162. // a pathname from directory syntax (trailing separator) to filename syntax.
  163. //
  164. // On Windows this method also replaces the alternate path separator '/' with
  165. // the primary path separator '\\', so that for example "bar\\/\\foo" becomes
  166. // "bar\\foo".
  167. void Normalize();
  168. // Returns a pointer to the last occurrence of a valid path separator in
  169. // the FilePath. On Windows, for example, both '/' and '\' are valid path
  170. // separators. Returns NULL if no path separator was found.
  171. const char* FindLastPathSeparator() const;
  172. std::string pathname_;
  173. }; // class FilePath
  174. } // namespace internal
  175. } // namespace testing
  176. GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
  177. #endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_