← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mozc/oneiric

« back to all changes in this revision

Viewing changes to third_party/gtest/test/gtest-filepath_test.cc

  • Committer: Bazaar Package Importer
  • Author(s): Nobuhiro Iwamatsu
  • Date: 2010-07-14 03:26:47 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100714032647-13qjisj6m8cm8jdx
Tags: 0.12.410.102-1
http://bugs.debian.org/588971
http://bugs.debian.org/588972
* New upstream release (Closes: #588971).
  - Add mozc-server, mozc-utils-gui and scim-mozc packages.
* Update debian/rules.
  Add --gypdir option to build_mozc.py.
* Update debian/control.
  - Bumped standards-version to 3.9.0.
  - Update description.
* Add mozc icon (Closes: #588972).
* Add patch which revises issue 18.
  ibus_mozc_issue18.patch
* kFreeBSD build support.
  support_kfreebsd.patch

Show diffs side-by-side

added added

removed removed

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