/Unittests/googletest/test/gtest-filepath_test.cc

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