?login_element?

Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download | RSS feed

  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 file tests classes and functions used internally by
  33. // Google Test.  They are subject to change without notice.
  34. //
  35. // This file is #included from gtest-internal.h.
  36. // Do not #include this file anywhere else!
  37.  
  38. #include "gtest/internal/gtest-filepath.h"
  39. #include "gtest/gtest.h"
  40. #include "src/gtest-internal-inl.h"
  41.  
  42. #if GTEST_OS_WINDOWS_MOBILE
  43. # include <windows.h>  // NOLINT
  44. #elif GTEST_OS_WINDOWS
  45. # include <direct.h>  // NOLINT
  46. #endif  // GTEST_OS_WINDOWS_MOBILE
  47.  
  48. namespace testing {
  49. namespace internal {
  50. namespace {
  51.  
  52. #if GTEST_OS_WINDOWS_MOBILE
  53. // FIXME: Move these to the POSIX adapter section in
  54. // gtest-port.h.
  55.  
  56. // Windows CE doesn't have the remove C function.
  57. int remove(const char* path) {
  58.   LPCWSTR wpath = String::AnsiToUtf16(path);
  59.   int ret = DeleteFile(wpath) ? 0 : -1;
  60.   delete [] wpath;
  61.   return ret;
  62. }
  63. // Windows CE doesn't have the _rmdir C function.
  64. int _rmdir(const char* path) {
  65.   FilePath filepath(path);
  66.   LPCWSTR wpath = String::AnsiToUtf16(
  67.       filepath.RemoveTrailingPathSeparator().c_str());
  68.   int ret = RemoveDirectory(wpath) ? 0 : -1;
  69.   delete [] wpath;
  70.   return ret;
  71. }
  72.  
  73. #else
  74.  
  75. TEST(GetCurrentDirTest, ReturnsCurrentDir) {
  76.   const FilePath original_dir = FilePath::GetCurrentDir();
  77.   EXPECT_FALSE(original_dir.IsEmpty());
  78.  
  79.   posix::ChDir(GTEST_PATH_SEP_);
  80.   const FilePath cwd = FilePath::GetCurrentDir();
  81.   posix::ChDir(original_dir.c_str());
  82.  
  83. # if GTEST_OS_WINDOWS
  84.  
  85.   // Skips the ":".
  86.   const char* const cwd_without_drive = strchr(cwd.c_str(), ':');
  87.   ASSERT_TRUE(cwd_without_drive != NULL);
  88.   EXPECT_STREQ(GTEST_PATH_SEP_, cwd_without_drive + 1);
  89.  
  90. # else
  91.  
  92.   EXPECT_EQ(GTEST_PATH_SEP_, cwd.string());
  93.  
  94. # endif
  95. }
  96.  
  97. #endif  // GTEST_OS_WINDOWS_MOBILE
  98.  
  99. TEST(IsEmptyTest, ReturnsTrueForEmptyPath) {
  100.   EXPECT_TRUE(FilePath("").IsEmpty());
  101. }
  102.  
  103. TEST(IsEmptyTest, ReturnsFalseForNonEmptyPath) {
  104.   EXPECT_FALSE(FilePath("a").IsEmpty());
  105.   EXPECT_FALSE(FilePath(".").IsEmpty());
  106.   EXPECT_FALSE(FilePath("a/b").IsEmpty());
  107.   EXPECT_FALSE(FilePath("a\\b\\").IsEmpty());
  108. }
  109.  
  110. // RemoveDirectoryName "" -> ""
  111. TEST(RemoveDirectoryNameTest, WhenEmptyName) {
  112.   EXPECT_EQ("", FilePath("").RemoveDirectoryName().string());
  113. }
  114.  
  115. // RemoveDirectoryName "afile" -> "afile"
  116. TEST(RemoveDirectoryNameTest, ButNoDirectory) {
  117.   EXPECT_EQ("afile",
  118.       FilePath("afile").RemoveDirectoryName().string());
  119. }
  120.  
  121. // RemoveDirectoryName "/afile" -> "afile"
  122. TEST(RemoveDirectoryNameTest, RootFileShouldGiveFileName) {
  123.   EXPECT_EQ("afile",
  124.       FilePath(GTEST_PATH_SEP_ "afile").RemoveDirectoryName().string());
  125. }
  126.  
  127. // RemoveDirectoryName "adir/" -> ""
  128. TEST(RemoveDirectoryNameTest, WhereThereIsNoFileName) {
  129.   EXPECT_EQ("",
  130.       FilePath("adir" GTEST_PATH_SEP_).RemoveDirectoryName().string());
  131. }
  132.  
  133. // RemoveDirectoryName "adir/afile" -> "afile"
  134. TEST(RemoveDirectoryNameTest, ShouldGiveFileName) {
  135.   EXPECT_EQ("afile",
  136.       FilePath("adir" GTEST_PATH_SEP_ "afile").RemoveDirectoryName().string());
  137. }
  138.  
  139. // RemoveDirectoryName "adir/subdir/afile" -> "afile"
  140. TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileName) {
  141.   EXPECT_EQ("afile",
  142.       FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")
  143.       .RemoveDirectoryName().string());
  144. }
  145.  
  146. #if GTEST_HAS_ALT_PATH_SEP_
  147.  
  148. // Tests that RemoveDirectoryName() works with the alternate separator
  149. // on Windows.
  150.  
  151. // RemoveDirectoryName("/afile") -> "afile"
  152. TEST(RemoveDirectoryNameTest, RootFileShouldGiveFileNameForAlternateSeparator) {
  153.   EXPECT_EQ("afile", FilePath("/afile").RemoveDirectoryName().string());
  154. }
  155.  
  156. // RemoveDirectoryName("adir/") -> ""
  157. TEST(RemoveDirectoryNameTest, WhereThereIsNoFileNameForAlternateSeparator) {
  158.   EXPECT_EQ("", FilePath("adir/").RemoveDirectoryName().string());
  159. }
  160.  
  161. // RemoveDirectoryName("adir/afile") -> "afile"
  162. TEST(RemoveDirectoryNameTest, ShouldGiveFileNameForAlternateSeparator) {
  163.   EXPECT_EQ("afile", FilePath("adir/afile").RemoveDirectoryName().string());
  164. }
  165.  
  166. // RemoveDirectoryName("adir/subdir/afile") -> "afile"
  167. TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileNameForAlternateSeparator) {
  168.   EXPECT_EQ("afile",
  169.             FilePath("adir/subdir/afile").RemoveDirectoryName().string());
  170. }
  171.  
  172. #endif
  173.  
  174. // RemoveFileName "" -> "./"
  175. TEST(RemoveFileNameTest, EmptyName) {
  176. #if GTEST_OS_WINDOWS_MOBILE
  177.   // On Windows CE, we use the root as the current directory.
  178.   EXPECT_EQ(GTEST_PATH_SEP_, FilePath("").RemoveFileName().string());
  179. #else
  180.   EXPECT_EQ("." GTEST_PATH_SEP_, FilePath("").RemoveFileName().string());
  181. #endif
  182. }
  183.  
  184. // RemoveFileName "adir/" -> "adir/"
  185. TEST(RemoveFileNameTest, ButNoFile) {
  186.   EXPECT_EQ("adir" GTEST_PATH_SEP_,
  187.       FilePath("adir" GTEST_PATH_SEP_).RemoveFileName().string());
  188. }
  189.  
  190. // RemoveFileName "adir/afile" -> "adir/"
  191. TEST(RemoveFileNameTest, GivesDirName) {
  192.   EXPECT_EQ("adir" GTEST_PATH_SEP_,
  193.             FilePath("adir" GTEST_PATH_SEP_ "afile").RemoveFileName().string());
  194. }
  195.  
  196. // RemoveFileName "adir/subdir/afile" -> "adir/subdir/"
  197. TEST(RemoveFileNameTest, GivesDirAndSubDirName) {
  198.   EXPECT_EQ("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_,
  199.       FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")
  200.       .RemoveFileName().string());
  201. }
  202.  
  203. // RemoveFileName "/afile" -> "/"
  204. TEST(RemoveFileNameTest, GivesRootDir) {
  205.   EXPECT_EQ(GTEST_PATH_SEP_,
  206.       FilePath(GTEST_PATH_SEP_ "afile").RemoveFileName().string());
  207. }
  208.  
  209. #if GTEST_HAS_ALT_PATH_SEP_
  210.  
  211. // Tests that RemoveFileName() works with the alternate separator on
  212. // Windows.
  213.  
  214. // RemoveFileName("adir/") -> "adir/"
  215. TEST(RemoveFileNameTest, ButNoFileForAlternateSeparator) {
  216.   EXPECT_EQ("adir" GTEST_PATH_SEP_,
  217.             FilePath("adir/").RemoveFileName().string());
  218. }
  219.  
  220. // RemoveFileName("adir/afile") -> "adir/"
  221. TEST(RemoveFileNameTest, GivesDirNameForAlternateSeparator) {
  222.   EXPECT_EQ("adir" GTEST_PATH_SEP_,
  223.             FilePath("adir/afile").RemoveFileName().string());
  224. }
  225.  
  226. // RemoveFileName("adir/subdir/afile") -> "adir/subdir/"
  227. TEST(RemoveFileNameTest, GivesDirAndSubDirNameForAlternateSeparator) {
  228.   EXPECT_EQ("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_,
  229.             FilePath("adir/subdir/afile").RemoveFileName().string());
  230. }
  231.  
  232. // RemoveFileName("/afile") -> "\"
  233. TEST(RemoveFileNameTest, GivesRootDirForAlternateSeparator) {
  234.   EXPECT_EQ(GTEST_PATH_SEP_, FilePath("/afile").RemoveFileName().string());
  235. }
  236.  
  237. #endif
  238.  
  239. TEST(MakeFileNameTest, GenerateWhenNumberIsZero) {
  240.   FilePath actual = FilePath::MakeFileName(FilePath("foo"), FilePath("bar"),
  241.       0, "xml");
  242.   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.string());
  243. }
  244.  
  245. TEST(MakeFileNameTest, GenerateFileNameNumberGtZero) {
  246.   FilePath actual = FilePath::MakeFileName(FilePath("foo"), FilePath("bar"),
  247.       12, "xml");
  248.   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.string());
  249. }
  250.  
  251. TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberIsZero) {
  252.   FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),
  253.       FilePath("bar"), 0, "xml");
  254.   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.string());
  255. }
  256.  
  257. TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberGtZero) {
  258.   FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),
  259.       FilePath("bar"), 12, "xml");
  260.   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.string());
  261. }
  262.  
  263. TEST(MakeFileNameTest, GenerateWhenNumberIsZeroAndDirIsEmpty) {
  264.   FilePath actual = FilePath::MakeFileName(FilePath(""), FilePath("bar"),
  265.       0, "xml");
  266.   EXPECT_EQ("bar.xml", actual.string());
  267. }
  268.  
  269. TEST(MakeFileNameTest, GenerateWhenNumberIsNotZeroAndDirIsEmpty) {
  270.   FilePath actual = FilePath::MakeFileName(FilePath(""), FilePath("bar"),
  271.       14, "xml");
  272.   EXPECT_EQ("bar_14.xml", actual.string());
  273. }
  274.  
  275. TEST(ConcatPathsTest, WorksWhenDirDoesNotEndWithPathSep) {
  276.   FilePath actual = FilePath::ConcatPaths(FilePath("foo"),
  277.                                           FilePath("bar.xml"));
  278.   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.string());
  279. }
  280.  
  281. TEST(ConcatPathsTest, WorksWhenPath1EndsWithPathSep) {
  282.   FilePath actual = FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_),
  283.                                           FilePath("bar.xml"));
  284.   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.string());
  285. }
  286.  
  287. TEST(ConcatPathsTest, Path1BeingEmpty) {
  288.   FilePath actual = FilePath::ConcatPaths(FilePath(""),
  289.                                           FilePath("bar.xml"));
  290.   EXPECT_EQ("bar.xml", actual.string());
  291. }
  292.  
  293. TEST(ConcatPathsTest, Path2BeingEmpty) {
  294.   FilePath actual = FilePath::ConcatPaths(FilePath("foo"), FilePath(""));
  295.   EXPECT_EQ("foo" GTEST_PATH_SEP_, actual.string());
  296. }
  297.  
  298. TEST(ConcatPathsTest, BothPathBeingEmpty) {
  299.   FilePath actual = FilePath::ConcatPaths(FilePath(""),
  300.                                           FilePath(""));
  301.   EXPECT_EQ("", actual.string());
  302. }
  303.  
  304. TEST(ConcatPathsTest, Path1ContainsPathSep) {
  305.   FilePath actual = FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_ "bar"),
  306.                                           FilePath("foobar.xml"));
  307.   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_ "foobar.xml",
  308.             actual.string());
  309. }
  310.  
  311. TEST(ConcatPathsTest, Path2ContainsPathSep) {
  312.   FilePath actual = FilePath::ConcatPaths(
  313.       FilePath("foo" GTEST_PATH_SEP_),
  314.       FilePath("bar" GTEST_PATH_SEP_ "bar.xml"));
  315.   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_ "bar.xml",
  316.             actual.string());
  317. }
  318.  
  319. TEST(ConcatPathsTest, Path2EndsWithPathSep) {
  320.   FilePath actual = FilePath::ConcatPaths(FilePath("foo"),
  321.                                           FilePath("bar" GTEST_PATH_SEP_));
  322.   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_, actual.string());
  323. }
  324.  
  325. // RemoveTrailingPathSeparator "" -> ""
  326. TEST(RemoveTrailingPathSeparatorTest, EmptyString) {
  327.   EXPECT_EQ("", FilePath("").RemoveTrailingPathSeparator().string());
  328. }
  329.  
  330. // RemoveTrailingPathSeparator "foo" -> "foo"
  331. TEST(RemoveTrailingPathSeparatorTest, FileNoSlashString) {
  332.   EXPECT_EQ("foo", FilePath("foo").RemoveTrailingPathSeparator().string());
  333. }
  334.  
  335. // RemoveTrailingPathSeparator "foo/" -> "foo"
  336. TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveTrailingSeparator) {
  337.   EXPECT_EQ("foo",
  338.       FilePath("foo" GTEST_PATH_SEP_).RemoveTrailingPathSeparator().string());
  339. #if GTEST_HAS_ALT_PATH_SEP_
  340.   EXPECT_EQ("foo", FilePath("foo/").RemoveTrailingPathSeparator().string());
  341. #endif
  342. }
  343.  
  344. // RemoveTrailingPathSeparator "foo/bar/" -> "foo/bar/"
  345. TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveLastSeparator) {
  346.   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
  347.             FilePath("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_)
  348.                 .RemoveTrailingPathSeparator().string());
  349. }
  350.  
  351. // RemoveTrailingPathSeparator "foo/bar" -> "foo/bar"
  352. TEST(RemoveTrailingPathSeparatorTest, ShouldReturnUnmodified) {
  353.   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
  354.             FilePath("foo" GTEST_PATH_SEP_ "bar")
  355.                 .RemoveTrailingPathSeparator().string());
  356. }
  357.  
  358. TEST(DirectoryTest, RootDirectoryExists) {
  359. #if GTEST_OS_WINDOWS  // We are on Windows.
  360.   char current_drive[_MAX_PATH];  // NOLINT
  361.   current_drive[0] = static_cast<char>(_getdrive() + 'A' - 1);
  362.   current_drive[1] = ':';
  363.   current_drive[2] = '\\';
  364.   current_drive[3] = '\0';
  365.   EXPECT_TRUE(FilePath(current_drive).DirectoryExists());
  366. #else
  367.   EXPECT_TRUE(FilePath("/").DirectoryExists());
  368. #endif  // GTEST_OS_WINDOWS
  369. }
  370.  
  371. #if GTEST_OS_WINDOWS
  372. TEST(DirectoryTest, RootOfWrongDriveDoesNotExists) {
  373.   const int saved_drive_ = _getdrive();
  374.   // Find a drive that doesn't exist. Start with 'Z' to avoid common ones.
  375.   for (char drive = 'Z'; drive >= 'A'; drive--)
  376.     if (_chdrive(drive - 'A' + 1) == -1) {
  377.       char non_drive[_MAX_PATH];  // NOLINT
  378.       non_drive[0] = drive;
  379.       non_drive[1] = ':';
  380.       non_drive[2] = '\\';
  381.       non_drive[3] = '\0';
  382.       EXPECT_FALSE(FilePath(non_drive).DirectoryExists());
  383.       break;
  384.     }
  385.   _chdrive(saved_drive_);
  386. }
  387. #endif  // GTEST_OS_WINDOWS
  388.  
  389. #if !GTEST_OS_WINDOWS_MOBILE
  390. // Windows CE _does_ consider an empty directory to exist.
  391. TEST(DirectoryTest, EmptyPathDirectoryDoesNotExist) {
  392.   EXPECT_FALSE(FilePath("").DirectoryExists());
  393. }
  394. #endif  // !GTEST_OS_WINDOWS_MOBILE
  395.  
  396. TEST(DirectoryTest, CurrentDirectoryExists) {
  397. #if GTEST_OS_WINDOWS  // We are on Windows.
  398. # ifndef _WIN32_CE  // Windows CE doesn't have a current directory.
  399.  
  400.   EXPECT_TRUE(FilePath(".").DirectoryExists());
  401.   EXPECT_TRUE(FilePath(".\\").DirectoryExists());
  402.  
  403. # endif  // _WIN32_CE
  404. #else
  405.   EXPECT_TRUE(FilePath(".").DirectoryExists());
  406.   EXPECT_TRUE(FilePath("./").DirectoryExists());
  407. #endif  // GTEST_OS_WINDOWS
  408. }
  409.  
  410. // "foo/bar" == foo//bar" == "foo///bar"
  411. TEST(NormalizeTest, MultipleConsecutiveSepaparatorsInMidstring) {
  412.   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
  413.             FilePath("foo" GTEST_PATH_SEP_ "bar").string());
  414.   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
  415.             FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string());
  416.   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
  417.             FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_
  418.                      GTEST_PATH_SEP_ "bar").string());
  419. }
  420.  
  421. // "/bar" == //bar" == "///bar"
  422. TEST(NormalizeTest, MultipleConsecutiveSepaparatorsAtStringStart) {
  423.   EXPECT_EQ(GTEST_PATH_SEP_ "bar",
  424.     FilePath(GTEST_PATH_SEP_ "bar").string());
  425.   EXPECT_EQ(GTEST_PATH_SEP_ "bar",
  426.     FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string());
  427.   EXPECT_EQ(GTEST_PATH_SEP_ "bar",
  428.     FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string());
  429. }
  430.  
  431. // "foo/" == foo//" == "foo///"
  432. TEST(NormalizeTest, MultipleConsecutiveSepaparatorsAtStringEnd) {
  433.   EXPECT_EQ("foo" GTEST_PATH_SEP_,
  434.     FilePath("foo" GTEST_PATH_SEP_).string());
  435.   EXPECT_EQ("foo" GTEST_PATH_SEP_,
  436.     FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_).string());
  437.   EXPECT_EQ("foo" GTEST_PATH_SEP_,
  438.     FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_).string());
  439. }
  440.  
  441. #if GTEST_HAS_ALT_PATH_SEP_
  442.  
  443. // Tests that separators at the end of the string are normalized
  444. // regardless of their combination (e.g. "foo\" =="foo/\" ==
  445. // "foo\\/").
  446. TEST(NormalizeTest, MixAlternateSeparatorAtStringEnd) {
  447.   EXPECT_EQ("foo" GTEST_PATH_SEP_,
  448.             FilePath("foo/").string());
  449.   EXPECT_EQ("foo" GTEST_PATH_SEP_,
  450.             FilePath("foo" GTEST_PATH_SEP_ "/").string());
  451.   EXPECT_EQ("foo" GTEST_PATH_SEP_,
  452.             FilePath("foo//" GTEST_PATH_SEP_).string());
  453. }
  454.  
  455. #endif
  456.  
  457. TEST(AssignmentOperatorTest, DefaultAssignedToNonDefault) {
  458.   FilePath default_path;
  459.   FilePath non_default_path("path");
  460.   non_default_path = default_path;
  461.   EXPECT_EQ("", non_default_path.string());
  462.   EXPECT_EQ("", default_path.string());  // RHS var is unchanged.
  463. }
  464.  
  465. TEST(AssignmentOperatorTest, NonDefaultAssignedToDefault) {
  466.   FilePath non_default_path("path");
  467.   FilePath default_path;
  468.   default_path = non_default_path;
  469.   EXPECT_EQ("path", default_path.string());
  470.   EXPECT_EQ("path", non_default_path.string());  // RHS var is unchanged.
  471. }
  472.  
  473. TEST(AssignmentOperatorTest, ConstAssignedToNonConst) {
  474.   const FilePath const_default_path("const_path");
  475.   FilePath non_default_path("path");
  476.   non_default_path = const_default_path;
  477.   EXPECT_EQ("const_path", non_default_path.string());
  478. }
  479.  
  480. class DirectoryCreationTest : public Test {
  481.  protected:
  482.   virtual void SetUp() {
  483.     testdata_path_.Set(FilePath(
  484.         TempDir() + GetCurrentExecutableName().string() +
  485.         "_directory_creation" GTEST_PATH_SEP_ "test" GTEST_PATH_SEP_));
  486.     testdata_file_.Set(testdata_path_.RemoveTrailingPathSeparator());
  487.  
  488.     unique_file0_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),
  489.         0, "txt"));
  490.     unique_file1_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),
  491.         1, "txt"));
  492.  
  493.     remove(testdata_file_.c_str());
  494.     remove(unique_file0_.c_str());
  495.     remove(unique_file1_.c_str());
  496.     posix::RmDir(testdata_path_.c_str());
  497.   }
  498.  
  499.   virtual void TearDown() {
  500.     remove(testdata_file_.c_str());
  501.     remove(unique_file0_.c_str());
  502.     remove(unique_file1_.c_str());
  503.     posix::RmDir(testdata_path_.c_str());
  504.   }
  505.  
  506.   void CreateTextFile(const char* filename) {
  507.     FILE* f = posix::FOpen(filename, "w");
  508.     fprintf(f, "text\n");
  509.     fclose(f);
  510.   }
  511.  
  512.   // Strings representing a directory and a file, with identical paths
  513.   // except for the trailing separator character that distinquishes
  514.   // a directory named 'test' from a file named 'test'. Example names:
  515.   FilePath testdata_path_;  // "/tmp/directory_creation/test/"
  516.   FilePath testdata_file_;  // "/tmp/directory_creation/test"
  517.   FilePath unique_file0_;  // "/tmp/directory_creation/test/unique.txt"
  518.   FilePath unique_file1_;  // "/tmp/directory_creation/test/unique_1.txt"
  519. };
  520.  
  521. TEST_F(DirectoryCreationTest, CreateDirectoriesRecursively) {
  522.   EXPECT_FALSE(testdata_path_.DirectoryExists()) << testdata_path_.string();
  523.   EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());
  524.   EXPECT_TRUE(testdata_path_.DirectoryExists());
  525. }
  526.  
  527. TEST_F(DirectoryCreationTest, CreateDirectoriesForAlreadyExistingPath) {
  528.   EXPECT_FALSE(testdata_path_.DirectoryExists()) << testdata_path_.string();
  529.   EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());
  530.   // Call 'create' again... should still succeed.
  531.   EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());
  532. }
  533.  
  534. TEST_F(DirectoryCreationTest, CreateDirectoriesAndUniqueFilename) {
  535.   FilePath file_path(FilePath::GenerateUniqueFileName(testdata_path_,
  536.       FilePath("unique"), "txt"));
  537.   EXPECT_EQ(unique_file0_.string(), file_path.string());
  538.   EXPECT_FALSE(file_path.FileOrDirectoryExists());  // file not there
  539.  
  540.   testdata_path_.CreateDirectoriesRecursively();
  541.   EXPECT_FALSE(file_path.FileOrDirectoryExists());  // file still not there
  542.   CreateTextFile(file_path.c_str());
  543.   EXPECT_TRUE(file_path.FileOrDirectoryExists());
  544.  
  545.   FilePath file_path2(FilePath::GenerateUniqueFileName(testdata_path_,
  546.       FilePath("unique"), "txt"));
  547.   EXPECT_EQ(unique_file1_.string(), file_path2.string());
  548.   EXPECT_FALSE(file_path2.FileOrDirectoryExists());  // file not there
  549.   CreateTextFile(file_path2.c_str());
  550.   EXPECT_TRUE(file_path2.FileOrDirectoryExists());
  551. }
  552.  
  553. TEST_F(DirectoryCreationTest, CreateDirectoriesFail) {
  554.   // force a failure by putting a file where we will try to create a directory.
  555.   CreateTextFile(testdata_file_.c_str());
  556.   EXPECT_TRUE(testdata_file_.FileOrDirectoryExists());
  557.   EXPECT_FALSE(testdata_file_.DirectoryExists());
  558.   EXPECT_FALSE(testdata_file_.CreateDirectoriesRecursively());
  559. }
  560.  
  561. TEST(NoDirectoryCreationTest, CreateNoDirectoriesForDefaultXmlFile) {
  562.   const FilePath test_detail_xml("test_detail.xml");
  563.   EXPECT_FALSE(test_detail_xml.CreateDirectoriesRecursively());
  564. }
  565.  
  566. TEST(FilePathTest, DefaultConstructor) {
  567.   FilePath fp;
  568.   EXPECT_EQ("", fp.string());
  569. }
  570.  
  571. TEST(FilePathTest, CharAndCopyConstructors) {
  572.   const FilePath fp("spicy");
  573.   EXPECT_EQ("spicy", fp.string());
  574.  
  575.   const FilePath fp_copy(fp);
  576.   EXPECT_EQ("spicy", fp_copy.string());
  577. }
  578.  
  579. TEST(FilePathTest, StringConstructor) {
  580.   const FilePath fp(std::string("cider"));
  581.   EXPECT_EQ("cider", fp.string());
  582. }
  583.  
  584. TEST(FilePathTest, Set) {
  585.   const FilePath apple("apple");
  586.   FilePath mac("mac");
  587.   mac.Set(apple);  // Implement Set() since overloading operator= is forbidden.
  588.   EXPECT_EQ("apple", mac.string());
  589.   EXPECT_EQ("apple", apple.string());
  590. }
  591.  
  592. TEST(FilePathTest, ToString) {
  593.   const FilePath file("drink");
  594.   EXPECT_EQ("drink", file.string());
  595. }
  596.  
  597. TEST(FilePathTest, RemoveExtension) {
  598.   EXPECT_EQ("app", FilePath("app.cc").RemoveExtension("cc").string());
  599.   EXPECT_EQ("app", FilePath("app.exe").RemoveExtension("exe").string());
  600.   EXPECT_EQ("APP", FilePath("APP.EXE").RemoveExtension("exe").string());
  601. }
  602.  
  603. TEST(FilePathTest, RemoveExtensionWhenThereIsNoExtension) {
  604.   EXPECT_EQ("app", FilePath("app").RemoveExtension("exe").string());
  605. }
  606.  
  607. TEST(FilePathTest, IsDirectory) {
  608.   EXPECT_FALSE(FilePath("cola").IsDirectory());
  609.   EXPECT_TRUE(FilePath("koala" GTEST_PATH_SEP_).IsDirectory());
  610. #if GTEST_HAS_ALT_PATH_SEP_
  611.   EXPECT_TRUE(FilePath("koala/").IsDirectory());
  612. #endif
  613. }
  614.  
  615. TEST(FilePathTest, IsAbsolutePath) {
  616.   EXPECT_FALSE(FilePath("is" GTEST_PATH_SEP_ "relative").IsAbsolutePath());
  617.   EXPECT_FALSE(FilePath("").IsAbsolutePath());
  618. #if GTEST_OS_WINDOWS
  619.   EXPECT_TRUE(FilePath("c:\\" GTEST_PATH_SEP_ "is_not"
  620.                        GTEST_PATH_SEP_ "relative").IsAbsolutePath());
  621.   EXPECT_FALSE(FilePath("c:foo" GTEST_PATH_SEP_ "bar").IsAbsolutePath());
  622.   EXPECT_TRUE(FilePath("c:/" GTEST_PATH_SEP_ "is_not"
  623.                        GTEST_PATH_SEP_ "relative").IsAbsolutePath());
  624. #else
  625.   EXPECT_TRUE(FilePath(GTEST_PATH_SEP_ "is_not" GTEST_PATH_SEP_ "relative")
  626.               .IsAbsolutePath());
  627. #endif  // GTEST_OS_WINDOWS
  628. }
  629.  
  630. TEST(FilePathTest, IsRootDirectory) {
  631. #if GTEST_OS_WINDOWS
  632.   EXPECT_TRUE(FilePath("a:\\").IsRootDirectory());
  633.   EXPECT_TRUE(FilePath("Z:/").IsRootDirectory());
  634.   EXPECT_TRUE(FilePath("e://").IsRootDirectory());
  635.   EXPECT_FALSE(FilePath("").IsRootDirectory());
  636.   EXPECT_FALSE(FilePath("b:").IsRootDirectory());
  637.   EXPECT_FALSE(FilePath("b:a").IsRootDirectory());
  638.   EXPECT_FALSE(FilePath("8:/").IsRootDirectory());
  639.   EXPECT_FALSE(FilePath("c|/").IsRootDirectory());
  640. #else
  641.   EXPECT_TRUE(FilePath("/").IsRootDirectory());
  642.   EXPECT_TRUE(FilePath("//").IsRootDirectory());
  643.   EXPECT_FALSE(FilePath("").IsRootDirectory());
  644.   EXPECT_FALSE(FilePath("\\").IsRootDirectory());
  645.   EXPECT_FALSE(FilePath("/x").IsRootDirectory());
  646. #endif
  647. }
  648.  
  649. }  // namespace
  650. }  // namespace internal
  651. }  // namespace testing
  652.