The Tor Browser: media/webrtc/trunk/testing/gtest/test/gtest-filepath

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     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!

    41 #include "gtest/internal/gtest-filepath.h"

    42 #include "gtest/gtest.h"

    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_

    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

    59 namespace testing {

    60 namespace internal {

    61 namespace {

    63 #if GTEST_OS_WINDOWS_MOBILE

    64 // TODO(wan@google.com): Move these to the POSIX adapter section in

    65 // gtest-port.h.

    67 // Windows CE doesn't have the remove C function.

    68 int 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.

    75 int _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 }

    84 #else

    86 TEST(GetCurrentDirTest, ReturnsCurrentDir) {

    87   const FilePath original_dir = FilePath::GetCurrentDir();

    88   EXPECT_FALSE(original_dir.IsEmpty());

    90   posix::ChDir(GTEST_PATH_SEP_);

    91   const FilePath cwd = FilePath::GetCurrentDir();

    92   posix::ChDir(original_dir.c_str());

    94 # if GTEST_OS_WINDOWS

    96   // Skips the ":".

    97   const char* const cwd_without_drive = strchr(cwd.c_str(), ':');

    98   ASSERT_TRUE(cwd_without_drive != NULL);

    99   EXPECT_STREQ(GTEST_PATH_SEP_, cwd_without_drive + 1);

   101 # else

   103   EXPECT_STREQ(GTEST_PATH_SEP_, cwd.c_str());

   105 # endif

   106 }

   108 #endif  // GTEST_OS_WINDOWS_MOBILE

   110 TEST(IsEmptyTest, ReturnsTrueForEmptyPath) {

   111   EXPECT_TRUE(FilePath("").IsEmpty());

   112   EXPECT_TRUE(FilePath(NULL).IsEmpty());

   113 }

   115 TEST(IsEmptyTest, ReturnsFalseForNonEmptyPath) {

   116   EXPECT_FALSE(FilePath("a").IsEmpty());

   117   EXPECT_FALSE(FilePath(".").IsEmpty());

   118   EXPECT_FALSE(FilePath("a/b").IsEmpty());

   119   EXPECT_FALSE(FilePath("a\\b\\").IsEmpty());

   120 }

   122 // RemoveDirectoryName "" -> ""

   123 TEST(RemoveDirectoryNameTest, WhenEmptyName) {

   124   EXPECT_STREQ("", FilePath("").RemoveDirectoryName().c_str());

   125 }

   127 // RemoveDirectoryName "afile" -> "afile"

   128 TEST(RemoveDirectoryNameTest, ButNoDirectory) {

   129   EXPECT_STREQ("afile",

   130       FilePath("afile").RemoveDirectoryName().c_str());

   131 }

   133 // RemoveDirectoryName "/afile" -> "afile"

   134 TEST(RemoveDirectoryNameTest, RootFileShouldGiveFileName) {

   135   EXPECT_STREQ("afile",

   136       FilePath(GTEST_PATH_SEP_ "afile").RemoveDirectoryName().c_str());

   137 }

   139 // RemoveDirectoryName "adir/" -> ""

   140 TEST(RemoveDirectoryNameTest, WhereThereIsNoFileName) {

   141   EXPECT_STREQ("",

   142       FilePath("adir" GTEST_PATH_SEP_).RemoveDirectoryName().c_str());

   143 }

   145 // RemoveDirectoryName "adir/afile" -> "afile"

   146 TEST(RemoveDirectoryNameTest, ShouldGiveFileName) {

   147   EXPECT_STREQ("afile",

   148       FilePath("adir" GTEST_PATH_SEP_ "afile").RemoveDirectoryName().c_str());

   149 }

   151 // RemoveDirectoryName "adir/subdir/afile" -> "afile"

   152 TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileName) {

   153   EXPECT_STREQ("afile",

   154       FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")

   155       .RemoveDirectoryName().c_str());

   156 }

   158 #if GTEST_HAS_ALT_PATH_SEP_

   160 // Tests that RemoveDirectoryName() works with the alternate separator

   161 // on Windows.

   163 // RemoveDirectoryName("/afile") -> "afile"

   164 TEST(RemoveDirectoryNameTest, RootFileShouldGiveFileNameForAlternateSeparator) {

   165   EXPECT_STREQ("afile",

   166                FilePath("/afile").RemoveDirectoryName().c_str());

   167 }

   169 // RemoveDirectoryName("adir/") -> ""

   170 TEST(RemoveDirectoryNameTest, WhereThereIsNoFileNameForAlternateSeparator) {

   171   EXPECT_STREQ("",

   172                FilePath("adir/").RemoveDirectoryName().c_str());

   173 }

   175 // RemoveDirectoryName("adir/afile") -> "afile"

   176 TEST(RemoveDirectoryNameTest, ShouldGiveFileNameForAlternateSeparator) {

   177   EXPECT_STREQ("afile",

   178                FilePath("adir/afile").RemoveDirectoryName().c_str());

   179 }

   181 // RemoveDirectoryName("adir/subdir/afile") -> "afile"

   182 TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileNameForAlternateSeparator) {

   183   EXPECT_STREQ("afile",

   184                FilePath("adir/subdir/afile").RemoveDirectoryName().c_str());

   185 }

   187 #endif

   189 // RemoveFileName "" -> "./"

   190 TEST(RemoveFileNameTest, EmptyName) {

   191 #if GTEST_OS_WINDOWS_MOBILE

   192   // On Windows CE, we use the root as the current directory.

   193   EXPECT_STREQ(GTEST_PATH_SEP_,

   194       FilePath("").RemoveFileName().c_str());

   195 #else

   196   EXPECT_STREQ("." GTEST_PATH_SEP_,

   197       FilePath("").RemoveFileName().c_str());

   198 #endif

   199 }

   201 // RemoveFileName "adir/" -> "adir/"

   202 TEST(RemoveFileNameTest, ButNoFile) {

   203   EXPECT_STREQ("adir" GTEST_PATH_SEP_,

   204       FilePath("adir" GTEST_PATH_SEP_).RemoveFileName().c_str());

   205 }

   207 // RemoveFileName "adir/afile" -> "adir/"

   208 TEST(RemoveFileNameTest, GivesDirName) {

   209   EXPECT_STREQ("adir" GTEST_PATH_SEP_,

   210       FilePath("adir" GTEST_PATH_SEP_ "afile")

   211       .RemoveFileName().c_str());

   212 }

   214 // RemoveFileName "adir/subdir/afile" -> "adir/subdir/"

   215 TEST(RemoveFileNameTest, GivesDirAndSubDirName) {

   216   EXPECT_STREQ("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_,

   217       FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")

   218       .RemoveFileName().c_str());

   219 }

   221 // RemoveFileName "/afile" -> "/"

   222 TEST(RemoveFileNameTest, GivesRootDir) {

   223   EXPECT_STREQ(GTEST_PATH_SEP_,

   224       FilePath(GTEST_PATH_SEP_ "afile").RemoveFileName().c_str());

   225 }

   227 #if GTEST_HAS_ALT_PATH_SEP_

   229 // Tests that RemoveFileName() works with the alternate separator on

   230 // Windows.

   232 // RemoveFileName("adir/") -> "adir/"

   233 TEST(RemoveFileNameTest, ButNoFileForAlternateSeparator) {

   234   EXPECT_STREQ("adir" GTEST_PATH_SEP_,

   235                FilePath("adir/").RemoveFileName().c_str());

   236 }

   238 // RemoveFileName("adir/afile") -> "adir/"

   239 TEST(RemoveFileNameTest, GivesDirNameForAlternateSeparator) {

   240   EXPECT_STREQ("adir" GTEST_PATH_SEP_,

   241                FilePath("adir/afile").RemoveFileName().c_str());

   242 }

   244 // RemoveFileName("adir/subdir/afile") -> "adir/subdir/"

   245 TEST(RemoveFileNameTest, GivesDirAndSubDirNameForAlternateSeparator) {

   246   EXPECT_STREQ("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_,

   247                FilePath("adir/subdir/afile").RemoveFileName().c_str());

   248 }

   250 // RemoveFileName("/afile") -> "\"

   251 TEST(RemoveFileNameTest, GivesRootDirForAlternateSeparator) {

   252   EXPECT_STREQ(GTEST_PATH_SEP_,

   253                FilePath("/afile").RemoveFileName().c_str());

   254 }

   256 #endif

   258 TEST(MakeFileNameTest, GenerateWhenNumberIsZero) {

   259   FilePath actual = FilePath::MakeFileName(FilePath("foo"), FilePath("bar"),

   260       0, "xml");

   261   EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());

   262 }

   264 TEST(MakeFileNameTest, GenerateFileNameNumberGtZero) {

   265   FilePath actual = FilePath::MakeFileName(FilePath("foo"), FilePath("bar"),

   266       12, "xml");

   267   EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.c_str());

   268 }

   270 TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberIsZero) {

   271   FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),

   272       FilePath("bar"), 0, "xml");

   273   EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());

   274 }

   276 TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberGtZero) {

   277   FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),

   278       FilePath("bar"), 12, "xml");

   279   EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.c_str());

   280 }

   282 TEST(MakeFileNameTest, GenerateWhenNumberIsZeroAndDirIsEmpty) {

   283   FilePath actual = FilePath::MakeFileName(FilePath(""), FilePath("bar"),

   284       0, "xml");

   285   EXPECT_STREQ("bar.xml", actual.c_str());

   286 }

   288 TEST(MakeFileNameTest, GenerateWhenNumberIsNotZeroAndDirIsEmpty) {

   289   FilePath actual = FilePath::MakeFileName(FilePath(""), FilePath("bar"),

   290       14, "xml");

   291   EXPECT_STREQ("bar_14.xml", actual.c_str());

   292 }

   294 TEST(ConcatPathsTest, WorksWhenDirDoesNotEndWithPathSep) {

   295   FilePath actual = FilePath::ConcatPaths(FilePath("foo"),

   296                                           FilePath("bar.xml"));

   297   EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());

   298 }

   300 TEST(ConcatPathsTest, WorksWhenPath1EndsWithPathSep) {

   301   FilePath actual = FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_),

   302                                           FilePath("bar.xml"));

   303   EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.c_str());

   304 }

   306 TEST(ConcatPathsTest, Path1BeingEmpty) {

   307   FilePath actual = FilePath::ConcatPaths(FilePath(""),

   308                                           FilePath("bar.xml"));

   309   EXPECT_STREQ("bar.xml", actual.c_str());

   310 }

   312 TEST(ConcatPathsTest, Path2BeingEmpty) {

   313   FilePath actual = FilePath::ConcatPaths(FilePath("foo"),

   314                                           FilePath(""));

   315   EXPECT_STREQ("foo" GTEST_PATH_SEP_, actual.c_str());

   316 }

   318 TEST(ConcatPathsTest, BothPathBeingEmpty) {

   319   FilePath actual = FilePath::ConcatPaths(FilePath(""),

   320                                           FilePath(""));

   321   EXPECT_STREQ("", actual.c_str());

   322 }

   324 TEST(ConcatPathsTest, Path1ContainsPathSep) {

   325   FilePath actual = FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_ "bar"),

   326                                           FilePath("foobar.xml"));

   327   EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_ "foobar.xml",

   328                actual.c_str());

   329 }

   331 TEST(ConcatPathsTest, Path2ContainsPathSep) {

   332   FilePath actual = FilePath::ConcatPaths(

   333       FilePath("foo" GTEST_PATH_SEP_),

   334       FilePath("bar" GTEST_PATH_SEP_ "bar.xml"));

   335   EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_ "bar.xml",

   336                actual.c_str());

   337 }

   339 TEST(ConcatPathsTest, Path2EndsWithPathSep) {

   340   FilePath actual = FilePath::ConcatPaths(FilePath("foo"),

   341                                           FilePath("bar" GTEST_PATH_SEP_));

   342   EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_, actual.c_str());

   343 }

   345 // RemoveTrailingPathSeparator "" -> ""

   346 TEST(RemoveTrailingPathSeparatorTest, EmptyString) {

   347   EXPECT_STREQ("",

   348       FilePath("").RemoveTrailingPathSeparator().c_str());

   349 }

   351 // RemoveTrailingPathSeparator "foo" -> "foo"

   352 TEST(RemoveTrailingPathSeparatorTest, FileNoSlashString) {

   353   EXPECT_STREQ("foo",

   354       FilePath("foo").RemoveTrailingPathSeparator().c_str());

   355 }

   357 // RemoveTrailingPathSeparator "foo/" -> "foo"

   358 TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveTrailingSeparator) {

   359   EXPECT_STREQ(

   360       "foo",

   361       FilePath("foo" GTEST_PATH_SEP_).RemoveTrailingPathSeparator().c_str());

   362 #if GTEST_HAS_ALT_PATH_SEP_

   363   EXPECT_STREQ("foo",

   364                FilePath("foo/").RemoveTrailingPathSeparator().c_str());

   365 #endif

   366 }

   368 // RemoveTrailingPathSeparator "foo/bar/" -> "foo/bar/"

   369 TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveLastSeparator) {

   370   EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar",

   371                FilePath("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_)

   372                .RemoveTrailingPathSeparator().c_str());

   373 }

   375 // RemoveTrailingPathSeparator "foo/bar" -> "foo/bar"

   376 TEST(RemoveTrailingPathSeparatorTest, ShouldReturnUnmodified) {

   377   EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar",

   378                FilePath("foo" GTEST_PATH_SEP_ "bar")

   379                .RemoveTrailingPathSeparator().c_str());

   380 }

   382 TEST(DirectoryTest, RootDirectoryExists) {

   383 #if GTEST_OS_WINDOWS  // We are on Windows.

   384   char current_drive[_MAX_PATH];  // NOLINT

   385   current_drive[0] = static_cast<char>(_getdrive() + 'A' - 1);

   386   current_drive[1] = ':';

   387   current_drive[2] = '\\';

   388   current_drive[3] = '\0';

   389   EXPECT_TRUE(FilePath(current_drive).DirectoryExists());

   390 #else

   391   EXPECT_TRUE(FilePath("/").DirectoryExists());

   392 #endif  // GTEST_OS_WINDOWS

   393 }

   395 #if GTEST_OS_WINDOWS

   396 TEST(DirectoryTest, RootOfWrongDriveDoesNotExists) {

   397   const int saved_drive_ = _getdrive();

   398   // Find a drive that doesn't exist. Start with 'Z' to avoid common ones.

   399   for (char drive = 'Z'; drive >= 'A'; drive--)

   400     if (_chdrive(drive - 'A' + 1) == -1) {

   401       char non_drive[_MAX_PATH];  // NOLINT

   402       non_drive[0] = drive;

   403       non_drive[1] = ':';

   404       non_drive[2] = '\\';

   405       non_drive[3] = '\0';

   406       EXPECT_FALSE(FilePath(non_drive).DirectoryExists());

   407       break;

   408     }

   409   _chdrive(saved_drive_);

   410 }

   411 #endif  // GTEST_OS_WINDOWS

   413 #if !GTEST_OS_WINDOWS_MOBILE

   414 // Windows CE _does_ consider an empty directory to exist.

   415 TEST(DirectoryTest, EmptyPathDirectoryDoesNotExist) {

   416   EXPECT_FALSE(FilePath("").DirectoryExists());

   417 }

   418 #endif  // !GTEST_OS_WINDOWS_MOBILE

   420 TEST(DirectoryTest, CurrentDirectoryExists) {

   421 #if GTEST_OS_WINDOWS  // We are on Windows.

   422 # ifndef _WIN32_CE  // Windows CE doesn't have a current directory.

   424   EXPECT_TRUE(FilePath(".").DirectoryExists());

   425   EXPECT_TRUE(FilePath(".\\").DirectoryExists());

   427 # endif  // _WIN32_CE

   428 #else

   429   EXPECT_TRUE(FilePath(".").DirectoryExists());

   430   EXPECT_TRUE(FilePath("./").DirectoryExists());

   431 #endif  // GTEST_OS_WINDOWS

   432 }

   434 TEST(NormalizeTest, NullStringsEqualEmptyDirectory) {

   435   EXPECT_STREQ("", FilePath(NULL).c_str());

   436   EXPECT_STREQ("", FilePath(String(NULL)).c_str());

   437 }

   439 // "foo/bar" == foo//bar" == "foo///bar"

   440 TEST(NormalizeTest, MultipleConsecutiveSepaparatorsInMidstring) {

   441   EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar",

   442                FilePath("foo" GTEST_PATH_SEP_ "bar").c_str());

   443   EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar",

   444                FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").c_str());

   445   EXPECT_STREQ("foo" GTEST_PATH_SEP_ "bar",

   446                FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_

   447                         GTEST_PATH_SEP_ "bar").c_str());

   448 }

   450 // "/bar" == //bar" == "///bar"

   451 TEST(NormalizeTest, MultipleConsecutiveSepaparatorsAtStringStart) {

   452   EXPECT_STREQ(GTEST_PATH_SEP_ "bar",

   453     FilePath(GTEST_PATH_SEP_ "bar").c_str());

   454   EXPECT_STREQ(GTEST_PATH_SEP_ "bar",

   455     FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").c_str());

   456   EXPECT_STREQ(GTEST_PATH_SEP_ "bar",

   457     FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").c_str());

   458 }

   460 // "foo/" == foo//" == "foo///"

   461 TEST(NormalizeTest, MultipleConsecutiveSepaparatorsAtStringEnd) {

   462   EXPECT_STREQ("foo" GTEST_PATH_SEP_,

   463     FilePath("foo" GTEST_PATH_SEP_).c_str());

   464   EXPECT_STREQ("foo" GTEST_PATH_SEP_,

   465     FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_).c_str());

   466   EXPECT_STREQ("foo" GTEST_PATH_SEP_,

   467     FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_).c_str());

   468 }

   470 #if GTEST_HAS_ALT_PATH_SEP_

   472 // Tests that separators at the end of the string are normalized

   473 // regardless of their combination (e.g. "foo\" =="foo/\" ==

   474 // "foo\\/").

   475 TEST(NormalizeTest, MixAlternateSeparatorAtStringEnd) {

   476   EXPECT_STREQ("foo" GTEST_PATH_SEP_,

   477                FilePath("foo/").c_str());

   478   EXPECT_STREQ("foo" GTEST_PATH_SEP_,

   479                FilePath("foo" GTEST_PATH_SEP_ "/").c_str());

   480   EXPECT_STREQ("foo" GTEST_PATH_SEP_,

   481                FilePath("foo//" GTEST_PATH_SEP_).c_str());

   482 }

   484 #endif

   486 TEST(AssignmentOperatorTest, DefaultAssignedToNonDefault) {

   487   FilePath default_path;

   488   FilePath non_default_path("path");

   489   non_default_path = default_path;

   490   EXPECT_STREQ("", non_default_path.c_str());

   491   EXPECT_STREQ("", default_path.c_str());  // RHS var is unchanged.

   492 }

   494 TEST(AssignmentOperatorTest, NonDefaultAssignedToDefault) {

   495   FilePath non_default_path("path");

   496   FilePath default_path;

   497   default_path = non_default_path;

   498   EXPECT_STREQ("path", default_path.c_str());

   499   EXPECT_STREQ("path", non_default_path.c_str());  // RHS var is unchanged.

   500 }

   502 TEST(AssignmentOperatorTest, ConstAssignedToNonConst) {

   503   const FilePath const_default_path("const_path");

   504   FilePath non_default_path("path");

   505   non_default_path = const_default_path;

   506   EXPECT_STREQ("const_path", non_default_path.c_str());

   507 }

   509 class DirectoryCreationTest : public Test {

   510  protected:

   511   virtual void SetUp() {

   512     testdata_path_.Set(FilePath(String::Format("%s%s%s",

   513         TempDir().c_str(), GetCurrentExecutableName().c_str(),

   514         "_directory_creation" GTEST_PATH_SEP_ "test" GTEST_PATH_SEP_)));

   515     testdata_file_.Set(testdata_path_.RemoveTrailingPathSeparator());

   517     unique_file0_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),

   518         0, "txt"));

   519     unique_file1_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),

   520         1, "txt"));

   522     remove(testdata_file_.c_str());

   523     remove(unique_file0_.c_str());

   524     remove(unique_file1_.c_str());

   525     posix::RmDir(testdata_path_.c_str());

   526   }

   528   virtual void TearDown() {

   529     remove(testdata_file_.c_str());

   530     remove(unique_file0_.c_str());

   531     remove(unique_file1_.c_str());

   532     posix::RmDir(testdata_path_.c_str());

   533   }

   535   String TempDir() const {

   536 #if GTEST_OS_WINDOWS_MOBILE

   537     return String("\\temp\\");

   538 #elif GTEST_OS_WINDOWS

   539     const char* temp_dir = posix::GetEnv("TEMP");

   540     if (temp_dir == NULL || temp_dir[0] == '\0')

   541       return String("\\temp\\");

   542     else if (String(temp_dir).EndsWith("\\"))

   543       return String(temp_dir);

   544     else

   545       return String::Format("%s\\", temp_dir);

   546 #else

   547     return String("/tmp/");

   548 #endif  // GTEST_OS_WINDOWS_MOBILE

   549   }

   551   void CreateTextFile(const char* filename) {

   552     FILE* f = posix::FOpen(filename, "w");

   553     fprintf(f, "text\n");

   554     fclose(f);

   555   }

   557   // Strings representing a directory and a file, with identical paths

   558   // except for the trailing separator character that distinquishes

   559   // a directory named 'test' from a file named 'test'. Example names:

   560   FilePath testdata_path_;  // "/tmp/directory_creation/test/"

   561   FilePath testdata_file_;  // "/tmp/directory_creation/test"

   562   FilePath unique_file0_;  // "/tmp/directory_creation/test/unique.txt"

   563   FilePath unique_file1_;  // "/tmp/directory_creation/test/unique_1.txt"

   564 };

   566 TEST_F(DirectoryCreationTest, CreateDirectoriesRecursively) {

   567   EXPECT_FALSE(testdata_path_.DirectoryExists()) << testdata_path_.c_str();

   568   EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());

   569   EXPECT_TRUE(testdata_path_.DirectoryExists());

   570 }

   572 TEST_F(DirectoryCreationTest, CreateDirectoriesForAlreadyExistingPath) {

   573   EXPECT_FALSE(testdata_path_.DirectoryExists()) << testdata_path_.c_str();

   574   EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());

   575   // Call 'create' again... should still succeed.

   576   EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());

   577 }

   579 TEST_F(DirectoryCreationTest, CreateDirectoriesAndUniqueFilename) {

   580   FilePath file_path(FilePath::GenerateUniqueFileName(testdata_path_,

   581       FilePath("unique"), "txt"));

   582   EXPECT_STREQ(unique_file0_.c_str(), file_path.c_str());

   583   EXPECT_FALSE(file_path.FileOrDirectoryExists());  // file not there

   585   testdata_path_.CreateDirectoriesRecursively();

   586   EXPECT_FALSE(file_path.FileOrDirectoryExists());  // file still not there

   587   CreateTextFile(file_path.c_str());

   588   EXPECT_TRUE(file_path.FileOrDirectoryExists());

   590   FilePath file_path2(FilePath::GenerateUniqueFileName(testdata_path_,

   591       FilePath("unique"), "txt"));

   592   EXPECT_STREQ(unique_file1_.c_str(), file_path2.c_str());

   593   EXPECT_FALSE(file_path2.FileOrDirectoryExists());  // file not there

   594   CreateTextFile(file_path2.c_str());

   595   EXPECT_TRUE(file_path2.FileOrDirectoryExists());

   596 }

   598 TEST_F(DirectoryCreationTest, CreateDirectoriesFail) {

   599   // force a failure by putting a file where we will try to create a directory.

   600   CreateTextFile(testdata_file_.c_str());

   601   EXPECT_TRUE(testdata_file_.FileOrDirectoryExists());

   602   EXPECT_FALSE(testdata_file_.DirectoryExists());

   603   EXPECT_FALSE(testdata_file_.CreateDirectoriesRecursively());

   604 }

   606 TEST(NoDirectoryCreationTest, CreateNoDirectoriesForDefaultXmlFile) {

   607   const FilePath test_detail_xml("test_detail.xml");

   608   EXPECT_FALSE(test_detail_xml.CreateDirectoriesRecursively());

   609 }

   611 TEST(FilePathTest, DefaultConstructor) {

   612   FilePath fp;

   613   EXPECT_STREQ("", fp.c_str());

   614 }

   616 TEST(FilePathTest, CharAndCopyConstructors) {

   617   const FilePath fp("spicy");

   618   EXPECT_STREQ("spicy", fp.c_str());

   620   const FilePath fp_copy(fp);

   621   EXPECT_STREQ("spicy", fp_copy.c_str());

   622 }

   624 TEST(FilePathTest, StringConstructor) {

   625   const FilePath fp(String("cider"));

   626   EXPECT_STREQ("cider", fp.c_str());

   627 }

   629 TEST(FilePathTest, Set) {

   630   const FilePath apple("apple");

   631   FilePath mac("mac");

   632   mac.Set(apple);  // Implement Set() since overloading operator= is forbidden.

   633   EXPECT_STREQ("apple", mac.c_str());

   634   EXPECT_STREQ("apple", apple.c_str());

   635 }

   637 TEST(FilePathTest, ToString) {

   638   const FilePath file("drink");

   639   String str(file.ToString());

   640   EXPECT_STREQ("drink", str.c_str());

   641 }

   643 TEST(FilePathTest, RemoveExtension) {

   644   EXPECT_STREQ("app", FilePath("app.exe").RemoveExtension("exe").c_str());

   645   EXPECT_STREQ("APP", FilePath("APP.EXE").RemoveExtension("exe").c_str());

   646 }

   648 TEST(FilePathTest, RemoveExtensionWhenThereIsNoExtension) {

   649   EXPECT_STREQ("app", FilePath("app").RemoveExtension("exe").c_str());

   650 }

   652 TEST(FilePathTest, IsDirectory) {

   653   EXPECT_FALSE(FilePath("cola").IsDirectory());

   654   EXPECT_TRUE(FilePath("koala" GTEST_PATH_SEP_).IsDirectory());

   655 #if GTEST_HAS_ALT_PATH_SEP_

   656   EXPECT_TRUE(FilePath("koala/").IsDirectory());

   657 #endif

   658 }

   660 TEST(FilePathTest, IsAbsolutePath) {

   661   EXPECT_FALSE(FilePath("is" GTEST_PATH_SEP_ "relative").IsAbsolutePath());

   662   EXPECT_FALSE(FilePath("").IsAbsolutePath());

   663 #if GTEST_OS_WINDOWS

   664   EXPECT_TRUE(FilePath("c:\\" GTEST_PATH_SEP_ "is_not"

   665                        GTEST_PATH_SEP_ "relative").IsAbsolutePath());

   666   EXPECT_FALSE(FilePath("c:foo" GTEST_PATH_SEP_ "bar").IsAbsolutePath());

   667   EXPECT_TRUE(FilePath("c:/" GTEST_PATH_SEP_ "is_not"

   668                        GTEST_PATH_SEP_ "relative").IsAbsolutePath());

   669 #else

   670   EXPECT_TRUE(FilePath(GTEST_PATH_SEP_ "is_not" GTEST_PATH_SEP_ "relative")

   671               .IsAbsolutePath());

   672 #endif  // GTEST_OS_WINDOWS

   673 }

   675 TEST(FilePathTest, IsRootDirectory) {

   676 #if GTEST_OS_WINDOWS

   677   EXPECT_TRUE(FilePath("a:\\").IsRootDirectory());

   678   EXPECT_TRUE(FilePath("Z:/").IsRootDirectory());

   679   EXPECT_TRUE(FilePath("e://").IsRootDirectory());

   680   EXPECT_FALSE(FilePath("").IsRootDirectory());

   681   EXPECT_FALSE(FilePath("b:").IsRootDirectory());

   682   EXPECT_FALSE(FilePath("b:a").IsRootDirectory());

   683   EXPECT_FALSE(FilePath("8:/").IsRootDirectory());

   684   EXPECT_FALSE(FilePath("c|/").IsRootDirectory());

   685 #else

   686   EXPECT_TRUE(FilePath("/").IsRootDirectory());

   687   EXPECT_TRUE(FilePath("//").IsRootDirectory());

   688   EXPECT_FALSE(FilePath("").IsRootDirectory());

   689   EXPECT_FALSE(FilePath("\\").IsRootDirectory());

   690   EXPECT_FALSE(FilePath("/x").IsRootDirectory());

   691 #endif

   692 }

   694 }  // namespace

   695 }  // namespace internal

   696 }  // namespace testing

The Tor Browser / file revision

media/webrtc/trunk/testing/gtest/test/gtest-filepath_test.cc@6474c204b198

media/webrtc/trunk/testing/gtest/test/gtest-filepath_test.cc