| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include <sstream> | |
| 6 | |
| 7 #include "base/basictypes.h" | |
| 8 #include "base/files/file_path.h" | |
| 9 #include "base/strings/utf_string_conversions.h" | |
| 10 #include "testing/gtest/include/gtest/gtest.h" | |
| 11 #include "testing/platform_test.h" | |
| 12 | |
| 13 #if defined(OS_POSIX) | |
| 14 #include "base/test/scoped_locale.h" | |
| 15 #endif | |
| 16 | |
| 17 // This macro helps avoid wrapped lines in the test structs. | |
| 18 #define FPL(x) FILE_PATH_LITERAL(x) | |
| 19 | |
| 20 // This macro constructs strings which can contain NULs. | |
| 21 #define FPS(x) FilePath::StringType(FPL(x), arraysize(FPL(x)) - 1) | |
| 22 | |
| 23 namespace base { | |
| 24 | |
| 25 struct UnaryTestData { | |
| 26 const FilePath::CharType* input; | |
| 27 const FilePath::CharType* expected; | |
| 28 }; | |
| 29 | |
| 30 struct UnaryBooleanTestData { | |
| 31 const FilePath::CharType* input; | |
| 32 bool expected; | |
| 33 }; | |
| 34 | |
| 35 struct BinaryTestData { | |
| 36 const FilePath::CharType* inputs[2]; | |
| 37 const FilePath::CharType* expected; | |
| 38 }; | |
| 39 | |
| 40 struct BinaryBooleanTestData { | |
| 41 const FilePath::CharType* inputs[2]; | |
| 42 bool expected; | |
| 43 }; | |
| 44 | |
| 45 struct BinaryIntTestData { | |
| 46 const FilePath::CharType* inputs[2]; | |
| 47 int expected; | |
| 48 }; | |
| 49 | |
| 50 struct UTF8TestData { | |
| 51 const FilePath::CharType* native; | |
| 52 const char* utf8; | |
| 53 }; | |
| 54 | |
| 55 // file_util winds up using autoreleased objects on the Mac, so this needs | |
| 56 // to be a PlatformTest | |
| 57 typedef PlatformTest FilePathTest; | |
| 58 | |
| 59 TEST_F(FilePathTest, DirName) { | |
| 60 const struct UnaryTestData cases[] = { | |
| 61 { FPL(""), FPL(".") }, | |
| 62 { FPL("aa"), FPL(".") }, | |
| 63 { FPL("/aa/bb"), FPL("/aa") }, | |
| 64 { FPL("/aa/bb/"), FPL("/aa") }, | |
| 65 { FPL("/aa/bb//"), FPL("/aa") }, | |
| 66 { FPL("/aa/bb/ccc"), FPL("/aa/bb") }, | |
| 67 { FPL("/aa"), FPL("/") }, | |
| 68 { FPL("/aa/"), FPL("/") }, | |
| 69 { FPL("/"), FPL("/") }, | |
| 70 { FPL("//"), FPL("//") }, | |
| 71 { FPL("///"), FPL("/") }, | |
| 72 { FPL("aa/"), FPL(".") }, | |
| 73 { FPL("aa/bb"), FPL("aa") }, | |
| 74 { FPL("aa/bb/"), FPL("aa") }, | |
| 75 { FPL("aa/bb//"), FPL("aa") }, | |
| 76 { FPL("aa//bb//"), FPL("aa") }, | |
| 77 { FPL("aa//bb/"), FPL("aa") }, | |
| 78 { FPL("aa//bb"), FPL("aa") }, | |
| 79 { FPL("//aa/bb"), FPL("//aa") }, | |
| 80 { FPL("//aa/"), FPL("//") }, | |
| 81 { FPL("//aa"), FPL("//") }, | |
| 82 { FPL("0:"), FPL(".") }, | |
| 83 { FPL("@:"), FPL(".") }, | |
| 84 { FPL("[:"), FPL(".") }, | |
| 85 { FPL("`:"), FPL(".") }, | |
| 86 { FPL("{:"), FPL(".") }, | |
| 87 { FPL("\xB3:"), FPL(".") }, | |
| 88 { FPL("\xC5:"), FPL(".") }, | |
| 89 #if defined(OS_WIN) | |
| 90 { FPL("\x0143:"), FPL(".") }, | |
| 91 #endif // OS_WIN | |
| 92 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 93 { FPL("c:"), FPL("c:") }, | |
| 94 { FPL("C:"), FPL("C:") }, | |
| 95 { FPL("A:"), FPL("A:") }, | |
| 96 { FPL("Z:"), FPL("Z:") }, | |
| 97 { FPL("a:"), FPL("a:") }, | |
| 98 { FPL("z:"), FPL("z:") }, | |
| 99 { FPL("c:aa"), FPL("c:") }, | |
| 100 { FPL("c:/"), FPL("c:/") }, | |
| 101 { FPL("c://"), FPL("c://") }, | |
| 102 { FPL("c:///"), FPL("c:/") }, | |
| 103 { FPL("c:/aa"), FPL("c:/") }, | |
| 104 { FPL("c:/aa/"), FPL("c:/") }, | |
| 105 { FPL("c:/aa/bb"), FPL("c:/aa") }, | |
| 106 { FPL("c:aa/bb"), FPL("c:aa") }, | |
| 107 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 108 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 109 { FPL("\\aa\\bb"), FPL("\\aa") }, | |
| 110 { FPL("\\aa\\bb\\"), FPL("\\aa") }, | |
| 111 { FPL("\\aa\\bb\\\\"), FPL("\\aa") }, | |
| 112 { FPL("\\aa\\bb\\ccc"), FPL("\\aa\\bb") }, | |
| 113 { FPL("\\aa"), FPL("\\") }, | |
| 114 { FPL("\\aa\\"), FPL("\\") }, | |
| 115 { FPL("\\"), FPL("\\") }, | |
| 116 { FPL("\\\\"), FPL("\\\\") }, | |
| 117 { FPL("\\\\\\"), FPL("\\") }, | |
| 118 { FPL("aa\\"), FPL(".") }, | |
| 119 { FPL("aa\\bb"), FPL("aa") }, | |
| 120 { FPL("aa\\bb\\"), FPL("aa") }, | |
| 121 { FPL("aa\\bb\\\\"), FPL("aa") }, | |
| 122 { FPL("aa\\\\bb\\\\"), FPL("aa") }, | |
| 123 { FPL("aa\\\\bb\\"), FPL("aa") }, | |
| 124 { FPL("aa\\\\bb"), FPL("aa") }, | |
| 125 { FPL("\\\\aa\\bb"), FPL("\\\\aa") }, | |
| 126 { FPL("\\\\aa\\"), FPL("\\\\") }, | |
| 127 { FPL("\\\\aa"), FPL("\\\\") }, | |
| 128 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 129 { FPL("c:\\"), FPL("c:\\") }, | |
| 130 { FPL("c:\\\\"), FPL("c:\\\\") }, | |
| 131 { FPL("c:\\\\\\"), FPL("c:\\") }, | |
| 132 { FPL("c:\\aa"), FPL("c:\\") }, | |
| 133 { FPL("c:\\aa\\"), FPL("c:\\") }, | |
| 134 { FPL("c:\\aa\\bb"), FPL("c:\\aa") }, | |
| 135 { FPL("c:aa\\bb"), FPL("c:aa") }, | |
| 136 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 137 #endif // FILE_PATH_USES_WIN_SEPARATORS | |
| 138 }; | |
| 139 | |
| 140 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 141 FilePath input(cases[i].input); | |
| 142 FilePath observed = input.DirName(); | |
| 143 EXPECT_EQ(FilePath::StringType(cases[i].expected), observed.value()) << | |
| 144 "i: " << i << ", input: " << input.value(); | |
| 145 } | |
| 146 } | |
| 147 | |
| 148 TEST_F(FilePathTest, BaseName) { | |
| 149 const struct UnaryTestData cases[] = { | |
| 150 { FPL(""), FPL("") }, | |
| 151 { FPL("aa"), FPL("aa") }, | |
| 152 { FPL("/aa/bb"), FPL("bb") }, | |
| 153 { FPL("/aa/bb/"), FPL("bb") }, | |
| 154 { FPL("/aa/bb//"), FPL("bb") }, | |
| 155 { FPL("/aa/bb/ccc"), FPL("ccc") }, | |
| 156 { FPL("/aa"), FPL("aa") }, | |
| 157 { FPL("/"), FPL("/") }, | |
| 158 { FPL("//"), FPL("//") }, | |
| 159 { FPL("///"), FPL("/") }, | |
| 160 { FPL("aa/"), FPL("aa") }, | |
| 161 { FPL("aa/bb"), FPL("bb") }, | |
| 162 { FPL("aa/bb/"), FPL("bb") }, | |
| 163 { FPL("aa/bb//"), FPL("bb") }, | |
| 164 { FPL("aa//bb//"), FPL("bb") }, | |
| 165 { FPL("aa//bb/"), FPL("bb") }, | |
| 166 { FPL("aa//bb"), FPL("bb") }, | |
| 167 { FPL("//aa/bb"), FPL("bb") }, | |
| 168 { FPL("//aa/"), FPL("aa") }, | |
| 169 { FPL("//aa"), FPL("aa") }, | |
| 170 { FPL("0:"), FPL("0:") }, | |
| 171 { FPL("@:"), FPL("@:") }, | |
| 172 { FPL("[:"), FPL("[:") }, | |
| 173 { FPL("`:"), FPL("`:") }, | |
| 174 { FPL("{:"), FPL("{:") }, | |
| 175 { FPL("\xB3:"), FPL("\xB3:") }, | |
| 176 { FPL("\xC5:"), FPL("\xC5:") }, | |
| 177 #if defined(OS_WIN) | |
| 178 { FPL("\x0143:"), FPL("\x0143:") }, | |
| 179 #endif // OS_WIN | |
| 180 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 181 { FPL("c:"), FPL("") }, | |
| 182 { FPL("C:"), FPL("") }, | |
| 183 { FPL("A:"), FPL("") }, | |
| 184 { FPL("Z:"), FPL("") }, | |
| 185 { FPL("a:"), FPL("") }, | |
| 186 { FPL("z:"), FPL("") }, | |
| 187 { FPL("c:aa"), FPL("aa") }, | |
| 188 { FPL("c:/"), FPL("/") }, | |
| 189 { FPL("c://"), FPL("//") }, | |
| 190 { FPL("c:///"), FPL("/") }, | |
| 191 { FPL("c:/aa"), FPL("aa") }, | |
| 192 { FPL("c:/aa/"), FPL("aa") }, | |
| 193 { FPL("c:/aa/bb"), FPL("bb") }, | |
| 194 { FPL("c:aa/bb"), FPL("bb") }, | |
| 195 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 196 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 197 { FPL("\\aa\\bb"), FPL("bb") }, | |
| 198 { FPL("\\aa\\bb\\"), FPL("bb") }, | |
| 199 { FPL("\\aa\\bb\\\\"), FPL("bb") }, | |
| 200 { FPL("\\aa\\bb\\ccc"), FPL("ccc") }, | |
| 201 { FPL("\\aa"), FPL("aa") }, | |
| 202 { FPL("\\"), FPL("\\") }, | |
| 203 { FPL("\\\\"), FPL("\\\\") }, | |
| 204 { FPL("\\\\\\"), FPL("\\") }, | |
| 205 { FPL("aa\\"), FPL("aa") }, | |
| 206 { FPL("aa\\bb"), FPL("bb") }, | |
| 207 { FPL("aa\\bb\\"), FPL("bb") }, | |
| 208 { FPL("aa\\bb\\\\"), FPL("bb") }, | |
| 209 { FPL("aa\\\\bb\\\\"), FPL("bb") }, | |
| 210 { FPL("aa\\\\bb\\"), FPL("bb") }, | |
| 211 { FPL("aa\\\\bb"), FPL("bb") }, | |
| 212 { FPL("\\\\aa\\bb"), FPL("bb") }, | |
| 213 { FPL("\\\\aa\\"), FPL("aa") }, | |
| 214 { FPL("\\\\aa"), FPL("aa") }, | |
| 215 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 216 { FPL("c:\\"), FPL("\\") }, | |
| 217 { FPL("c:\\\\"), FPL("\\\\") }, | |
| 218 { FPL("c:\\\\\\"), FPL("\\") }, | |
| 219 { FPL("c:\\aa"), FPL("aa") }, | |
| 220 { FPL("c:\\aa\\"), FPL("aa") }, | |
| 221 { FPL("c:\\aa\\bb"), FPL("bb") }, | |
| 222 { FPL("c:aa\\bb"), FPL("bb") }, | |
| 223 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 224 #endif // FILE_PATH_USES_WIN_SEPARATORS | |
| 225 }; | |
| 226 | |
| 227 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 228 FilePath input(cases[i].input); | |
| 229 FilePath observed = input.BaseName(); | |
| 230 EXPECT_EQ(FilePath::StringType(cases[i].expected), observed.value()) << | |
| 231 "i: " << i << ", input: " << input.value(); | |
| 232 } | |
| 233 } | |
| 234 | |
| 235 TEST_F(FilePathTest, Append) { | |
| 236 const struct BinaryTestData cases[] = { | |
| 237 { { FPL(""), FPL("cc") }, FPL("cc") }, | |
| 238 { { FPL("."), FPL("ff") }, FPL("ff") }, | |
| 239 { { FPL("/"), FPL("cc") }, FPL("/cc") }, | |
| 240 { { FPL("/aa"), FPL("") }, FPL("/aa") }, | |
| 241 { { FPL("/aa/"), FPL("") }, FPL("/aa") }, | |
| 242 { { FPL("//aa"), FPL("") }, FPL("//aa") }, | |
| 243 { { FPL("//aa/"), FPL("") }, FPL("//aa") }, | |
| 244 { { FPL("//"), FPL("aa") }, FPL("//aa") }, | |
| 245 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 246 { { FPL("c:"), FPL("a") }, FPL("c:a") }, | |
| 247 { { FPL("c:"), FPL("") }, FPL("c:") }, | |
| 248 { { FPL("c:/"), FPL("a") }, FPL("c:/a") }, | |
| 249 { { FPL("c://"), FPL("a") }, FPL("c://a") }, | |
| 250 { { FPL("c:///"), FPL("a") }, FPL("c:/a") }, | |
| 251 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 252 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 253 // Append introduces the default separator character, so these test cases | |
| 254 // need to be defined with different expected results on platforms that use | |
| 255 // different default separator characters. | |
| 256 { { FPL("\\"), FPL("cc") }, FPL("\\cc") }, | |
| 257 { { FPL("\\aa"), FPL("") }, FPL("\\aa") }, | |
| 258 { { FPL("\\aa\\"), FPL("") }, FPL("\\aa") }, | |
| 259 { { FPL("\\\\aa"), FPL("") }, FPL("\\\\aa") }, | |
| 260 { { FPL("\\\\aa\\"), FPL("") }, FPL("\\\\aa") }, | |
| 261 { { FPL("\\\\"), FPL("aa") }, FPL("\\\\aa") }, | |
| 262 { { FPL("/aa/bb"), FPL("cc") }, FPL("/aa/bb\\cc") }, | |
| 263 { { FPL("/aa/bb/"), FPL("cc") }, FPL("/aa/bb\\cc") }, | |
| 264 { { FPL("aa/bb/"), FPL("cc") }, FPL("aa/bb\\cc") }, | |
| 265 { { FPL("aa/bb"), FPL("cc") }, FPL("aa/bb\\cc") }, | |
| 266 { { FPL("a/b"), FPL("c") }, FPL("a/b\\c") }, | |
| 267 { { FPL("a/b/"), FPL("c") }, FPL("a/b\\c") }, | |
| 268 { { FPL("//aa"), FPL("bb") }, FPL("//aa\\bb") }, | |
| 269 { { FPL("//aa/"), FPL("bb") }, FPL("//aa\\bb") }, | |
| 270 { { FPL("\\aa\\bb"), FPL("cc") }, FPL("\\aa\\bb\\cc") }, | |
| 271 { { FPL("\\aa\\bb\\"), FPL("cc") }, FPL("\\aa\\bb\\cc") }, | |
| 272 { { FPL("aa\\bb\\"), FPL("cc") }, FPL("aa\\bb\\cc") }, | |
| 273 { { FPL("aa\\bb"), FPL("cc") }, FPL("aa\\bb\\cc") }, | |
| 274 { { FPL("a\\b"), FPL("c") }, FPL("a\\b\\c") }, | |
| 275 { { FPL("a\\b\\"), FPL("c") }, FPL("a\\b\\c") }, | |
| 276 { { FPL("\\\\aa"), FPL("bb") }, FPL("\\\\aa\\bb") }, | |
| 277 { { FPL("\\\\aa\\"), FPL("bb") }, FPL("\\\\aa\\bb") }, | |
| 278 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 279 { { FPL("c:\\"), FPL("a") }, FPL("c:\\a") }, | |
| 280 { { FPL("c:\\\\"), FPL("a") }, FPL("c:\\\\a") }, | |
| 281 { { FPL("c:\\\\\\"), FPL("a") }, FPL("c:\\a") }, | |
| 282 { { FPL("c:\\"), FPL("") }, FPL("c:\\") }, | |
| 283 { { FPL("c:\\a"), FPL("b") }, FPL("c:\\a\\b") }, | |
| 284 { { FPL("c:\\a\\"), FPL("b") }, FPL("c:\\a\\b") }, | |
| 285 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 286 #else // FILE_PATH_USES_WIN_SEPARATORS | |
| 287 { { FPL("/aa/bb"), FPL("cc") }, FPL("/aa/bb/cc") }, | |
| 288 { { FPL("/aa/bb/"), FPL("cc") }, FPL("/aa/bb/cc") }, | |
| 289 { { FPL("aa/bb/"), FPL("cc") }, FPL("aa/bb/cc") }, | |
| 290 { { FPL("aa/bb"), FPL("cc") }, FPL("aa/bb/cc") }, | |
| 291 { { FPL("a/b"), FPL("c") }, FPL("a/b/c") }, | |
| 292 { { FPL("a/b/"), FPL("c") }, FPL("a/b/c") }, | |
| 293 { { FPL("//aa"), FPL("bb") }, FPL("//aa/bb") }, | |
| 294 { { FPL("//aa/"), FPL("bb") }, FPL("//aa/bb") }, | |
| 295 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 296 { { FPL("c:/"), FPL("a") }, FPL("c:/a") }, | |
| 297 { { FPL("c:/"), FPL("") }, FPL("c:/") }, | |
| 298 { { FPL("c:/a"), FPL("b") }, FPL("c:/a/b") }, | |
| 299 { { FPL("c:/a/"), FPL("b") }, FPL("c:/a/b") }, | |
| 300 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 301 #endif // FILE_PATH_USES_WIN_SEPARATORS | |
| 302 }; | |
| 303 | |
| 304 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 305 FilePath root(cases[i].inputs[0]); | |
| 306 FilePath::StringType leaf(cases[i].inputs[1]); | |
| 307 FilePath observed_str = root.Append(leaf); | |
| 308 EXPECT_EQ(FilePath::StringType(cases[i].expected), observed_str.value()) << | |
| 309 "i: " << i << ", root: " << root.value() << ", leaf: " << leaf; | |
| 310 FilePath observed_path = root.Append(FilePath(leaf)); | |
| 311 EXPECT_EQ(FilePath::StringType(cases[i].expected), observed_path.value()) << | |
| 312 "i: " << i << ", root: " << root.value() << ", leaf: " << leaf; | |
| 313 | |
| 314 // TODO(erikkay): It would be nice to have a unicode test append value to | |
| 315 // handle the case when AppendASCII is passed UTF8 | |
| 316 #if defined(OS_WIN) | |
| 317 std::string ascii = WideToUTF8(leaf); | |
| 318 #elif defined(OS_POSIX) | |
| 319 std::string ascii = leaf; | |
| 320 #endif | |
| 321 observed_str = root.AppendASCII(ascii); | |
| 322 EXPECT_EQ(FilePath::StringType(cases[i].expected), observed_str.value()) << | |
| 323 "i: " << i << ", root: " << root.value() << ", leaf: " << leaf; | |
| 324 } | |
| 325 } | |
| 326 | |
| 327 TEST_F(FilePathTest, StripTrailingSeparators) { | |
| 328 const struct UnaryTestData cases[] = { | |
| 329 { FPL(""), FPL("") }, | |
| 330 { FPL("/"), FPL("/") }, | |
| 331 { FPL("//"), FPL("//") }, | |
| 332 { FPL("///"), FPL("/") }, | |
| 333 { FPL("////"), FPL("/") }, | |
| 334 { FPL("a/"), FPL("a") }, | |
| 335 { FPL("a//"), FPL("a") }, | |
| 336 { FPL("a///"), FPL("a") }, | |
| 337 { FPL("a////"), FPL("a") }, | |
| 338 { FPL("/a"), FPL("/a") }, | |
| 339 { FPL("/a/"), FPL("/a") }, | |
| 340 { FPL("/a//"), FPL("/a") }, | |
| 341 { FPL("/a///"), FPL("/a") }, | |
| 342 { FPL("/a////"), FPL("/a") }, | |
| 343 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 344 { FPL("c:"), FPL("c:") }, | |
| 345 { FPL("c:/"), FPL("c:/") }, | |
| 346 { FPL("c://"), FPL("c://") }, | |
| 347 { FPL("c:///"), FPL("c:/") }, | |
| 348 { FPL("c:////"), FPL("c:/") }, | |
| 349 { FPL("c:/a"), FPL("c:/a") }, | |
| 350 { FPL("c:/a/"), FPL("c:/a") }, | |
| 351 { FPL("c:/a//"), FPL("c:/a") }, | |
| 352 { FPL("c:/a///"), FPL("c:/a") }, | |
| 353 { FPL("c:/a////"), FPL("c:/a") }, | |
| 354 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 355 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 356 { FPL("\\"), FPL("\\") }, | |
| 357 { FPL("\\\\"), FPL("\\\\") }, | |
| 358 { FPL("\\\\\\"), FPL("\\") }, | |
| 359 { FPL("\\\\\\\\"), FPL("\\") }, | |
| 360 { FPL("a\\"), FPL("a") }, | |
| 361 { FPL("a\\\\"), FPL("a") }, | |
| 362 { FPL("a\\\\\\"), FPL("a") }, | |
| 363 { FPL("a\\\\\\\\"), FPL("a") }, | |
| 364 { FPL("\\a"), FPL("\\a") }, | |
| 365 { FPL("\\a\\"), FPL("\\a") }, | |
| 366 { FPL("\\a\\\\"), FPL("\\a") }, | |
| 367 { FPL("\\a\\\\\\"), FPL("\\a") }, | |
| 368 { FPL("\\a\\\\\\\\"), FPL("\\a") }, | |
| 369 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 370 { FPL("c:\\"), FPL("c:\\") }, | |
| 371 { FPL("c:\\\\"), FPL("c:\\\\") }, | |
| 372 { FPL("c:\\\\\\"), FPL("c:\\") }, | |
| 373 { FPL("c:\\\\\\\\"), FPL("c:\\") }, | |
| 374 { FPL("c:\\a"), FPL("c:\\a") }, | |
| 375 { FPL("c:\\a\\"), FPL("c:\\a") }, | |
| 376 { FPL("c:\\a\\\\"), FPL("c:\\a") }, | |
| 377 { FPL("c:\\a\\\\\\"), FPL("c:\\a") }, | |
| 378 { FPL("c:\\a\\\\\\\\"), FPL("c:\\a") }, | |
| 379 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 380 #endif // FILE_PATH_USES_WIN_SEPARATORS | |
| 381 }; | |
| 382 | |
| 383 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 384 FilePath input(cases[i].input); | |
| 385 FilePath observed = input.StripTrailingSeparators(); | |
| 386 EXPECT_EQ(FilePath::StringType(cases[i].expected), observed.value()) << | |
| 387 "i: " << i << ", input: " << input.value(); | |
| 388 } | |
| 389 } | |
| 390 | |
| 391 TEST_F(FilePathTest, IsAbsolute) { | |
| 392 const struct UnaryBooleanTestData cases[] = { | |
| 393 { FPL(""), false }, | |
| 394 { FPL("a"), false }, | |
| 395 { FPL("c:"), false }, | |
| 396 { FPL("c:a"), false }, | |
| 397 { FPL("a/b"), false }, | |
| 398 { FPL("//"), true }, | |
| 399 { FPL("//a"), true }, | |
| 400 { FPL("c:a/b"), false }, | |
| 401 { FPL("?:/a"), false }, | |
| 402 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 403 { FPL("/"), false }, | |
| 404 { FPL("/a"), false }, | |
| 405 { FPL("/."), false }, | |
| 406 { FPL("/.."), false }, | |
| 407 { FPL("c:/"), true }, | |
| 408 { FPL("c:/a"), true }, | |
| 409 { FPL("c:/."), true }, | |
| 410 { FPL("c:/.."), true }, | |
| 411 { FPL("C:/a"), true }, | |
| 412 { FPL("d:/a"), true }, | |
| 413 #else // FILE_PATH_USES_DRIVE_LETTERS | |
| 414 { FPL("/"), true }, | |
| 415 { FPL("/a"), true }, | |
| 416 { FPL("/."), true }, | |
| 417 { FPL("/.."), true }, | |
| 418 { FPL("c:/"), false }, | |
| 419 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 420 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 421 { FPL("a\\b"), false }, | |
| 422 { FPL("\\\\"), true }, | |
| 423 { FPL("\\\\a"), true }, | |
| 424 { FPL("a\\b"), false }, | |
| 425 { FPL("\\\\"), true }, | |
| 426 { FPL("//a"), true }, | |
| 427 { FPL("c:a\\b"), false }, | |
| 428 { FPL("?:\\a"), false }, | |
| 429 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 430 { FPL("\\"), false }, | |
| 431 { FPL("\\a"), false }, | |
| 432 { FPL("\\."), false }, | |
| 433 { FPL("\\.."), false }, | |
| 434 { FPL("c:\\"), true }, | |
| 435 { FPL("c:\\"), true }, | |
| 436 { FPL("c:\\a"), true }, | |
| 437 { FPL("c:\\."), true }, | |
| 438 { FPL("c:\\.."), true }, | |
| 439 { FPL("C:\\a"), true }, | |
| 440 { FPL("d:\\a"), true }, | |
| 441 #else // FILE_PATH_USES_DRIVE_LETTERS | |
| 442 { FPL("\\"), true }, | |
| 443 { FPL("\\a"), true }, | |
| 444 { FPL("\\."), true }, | |
| 445 { FPL("\\.."), true }, | |
| 446 { FPL("c:\\"), false }, | |
| 447 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 448 #endif // FILE_PATH_USES_WIN_SEPARATORS | |
| 449 }; | |
| 450 | |
| 451 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 452 FilePath input(cases[i].input); | |
| 453 bool observed = input.IsAbsolute(); | |
| 454 EXPECT_EQ(cases[i].expected, observed) << | |
| 455 "i: " << i << ", input: " << input.value(); | |
| 456 } | |
| 457 } | |
| 458 | |
| 459 TEST_F(FilePathTest, PathComponentsTest) { | |
| 460 const struct UnaryTestData cases[] = { | |
| 461 { FPL("//foo/bar/baz/"), FPL("|//|foo|bar|baz")}, | |
| 462 { FPL("///"), FPL("|/")}, | |
| 463 { FPL("/foo//bar//baz/"), FPL("|/|foo|bar|baz")}, | |
| 464 { FPL("/foo/bar/baz/"), FPL("|/|foo|bar|baz")}, | |
| 465 { FPL("/foo/bar/baz//"), FPL("|/|foo|bar|baz")}, | |
| 466 { FPL("/foo/bar/baz///"), FPL("|/|foo|bar|baz")}, | |
| 467 { FPL("/foo/bar/baz"), FPL("|/|foo|bar|baz")}, | |
| 468 { FPL("/foo/bar.bot/baz.txt"), FPL("|/|foo|bar.bot|baz.txt")}, | |
| 469 { FPL("//foo//bar/baz"), FPL("|//|foo|bar|baz")}, | |
| 470 { FPL("/"), FPL("|/")}, | |
| 471 { FPL("foo"), FPL("|foo")}, | |
| 472 { FPL(""), FPL("")}, | |
| 473 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 474 { FPL("e:/foo"), FPL("|e:|/|foo")}, | |
| 475 { FPL("e:/"), FPL("|e:|/")}, | |
| 476 { FPL("e:"), FPL("|e:")}, | |
| 477 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 478 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 479 { FPL("../foo"), FPL("|..|foo")}, | |
| 480 { FPL("./foo"), FPL("|foo")}, | |
| 481 { FPL("../foo/bar/"), FPL("|..|foo|bar") }, | |
| 482 { FPL("\\\\foo\\bar\\baz\\"), FPL("|\\\\|foo|bar|baz")}, | |
| 483 { FPL("\\\\\\"), FPL("|\\")}, | |
| 484 { FPL("\\foo\\\\bar\\\\baz\\"), FPL("|\\|foo|bar|baz")}, | |
| 485 { FPL("\\foo\\bar\\baz\\"), FPL("|\\|foo|bar|baz")}, | |
| 486 { FPL("\\foo\\bar\\baz\\\\"), FPL("|\\|foo|bar|baz")}, | |
| 487 { FPL("\\foo\\bar\\baz\\\\\\"), FPL("|\\|foo|bar|baz")}, | |
| 488 { FPL("\\foo\\bar\\baz"), FPL("|\\|foo|bar|baz")}, | |
| 489 { FPL("\\foo\\bar/baz\\\\\\"), FPL("|\\|foo|bar|baz")}, | |
| 490 { FPL("/foo\\bar\\baz"), FPL("|/|foo|bar|baz")}, | |
| 491 { FPL("\\foo\\bar.bot\\baz.txt"), FPL("|\\|foo|bar.bot|baz.txt")}, | |
| 492 { FPL("\\\\foo\\\\bar\\baz"), FPL("|\\\\|foo|bar|baz")}, | |
| 493 { FPL("\\"), FPL("|\\")}, | |
| 494 #endif // FILE_PATH_USES_WIN_SEPARATORS | |
| 495 }; | |
| 496 | |
| 497 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 498 FilePath input(cases[i].input); | |
| 499 std::vector<FilePath::StringType> comps; | |
| 500 input.GetComponents(&comps); | |
| 501 | |
| 502 FilePath::StringType observed; | |
| 503 for (size_t j = 0; j < comps.size(); ++j) { | |
| 504 observed.append(FILE_PATH_LITERAL("|"), 1); | |
| 505 observed.append(comps[j]); | |
| 506 } | |
| 507 EXPECT_EQ(FilePath::StringType(cases[i].expected), observed) << | |
| 508 "i: " << i << ", input: " << input.value(); | |
| 509 } | |
| 510 } | |
| 511 | |
| 512 TEST_F(FilePathTest, IsParentTest) { | |
| 513 const struct BinaryBooleanTestData cases[] = { | |
| 514 { { FPL("/"), FPL("/foo/bar/baz") }, true}, | |
| 515 { { FPL("/foo/bar"), FPL("/foo/bar/baz") }, true}, | |
| 516 { { FPL("/foo/bar/"), FPL("/foo/bar/baz") }, true}, | |
| 517 { { FPL("//foo/bar/"), FPL("//foo/bar/baz") }, true}, | |
| 518 { { FPL("/foo/bar"), FPL("/foo2/bar/baz") }, false}, | |
| 519 { { FPL("/foo/bar.txt"), FPL("/foo/bar/baz") }, false}, | |
| 520 { { FPL("/foo/bar"), FPL("/foo/bar2/baz") }, false}, | |
| 521 { { FPL("/foo/bar"), FPL("/foo/bar") }, false}, | |
| 522 { { FPL("/foo/bar/baz"), FPL("/foo/bar") }, false}, | |
| 523 { { FPL("foo/bar"), FPL("foo/bar/baz") }, true}, | |
| 524 { { FPL("foo/bar"), FPL("foo2/bar/baz") }, false}, | |
| 525 { { FPL("foo/bar"), FPL("foo/bar2/baz") }, false}, | |
| 526 { { FPL(""), FPL("foo") }, false}, | |
| 527 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 528 { { FPL("c:/foo/bar"), FPL("c:/foo/bar/baz") }, true}, | |
| 529 { { FPL("E:/foo/bar"), FPL("e:/foo/bar/baz") }, true}, | |
| 530 { { FPL("f:/foo/bar"), FPL("F:/foo/bar/baz") }, true}, | |
| 531 { { FPL("E:/Foo/bar"), FPL("e:/foo/bar/baz") }, false}, | |
| 532 { { FPL("f:/foo/bar"), FPL("F:/foo/Bar/baz") }, false}, | |
| 533 { { FPL("c:/"), FPL("c:/foo/bar/baz") }, true}, | |
| 534 { { FPL("c:"), FPL("c:/foo/bar/baz") }, true}, | |
| 535 { { FPL("c:/foo/bar"), FPL("d:/foo/bar/baz") }, false}, | |
| 536 { { FPL("c:/foo/bar"), FPL("D:/foo/bar/baz") }, false}, | |
| 537 { { FPL("C:/foo/bar"), FPL("d:/foo/bar/baz") }, false}, | |
| 538 { { FPL("c:/foo/bar"), FPL("c:/foo2/bar/baz") }, false}, | |
| 539 { { FPL("e:/foo/bar"), FPL("E:/foo2/bar/baz") }, false}, | |
| 540 { { FPL("F:/foo/bar"), FPL("f:/foo2/bar/baz") }, false}, | |
| 541 { { FPL("c:/foo/bar"), FPL("c:/foo/bar2/baz") }, false}, | |
| 542 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 543 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 544 { { FPL("\\foo\\bar"), FPL("\\foo\\bar\\baz") }, true}, | |
| 545 { { FPL("\\foo/bar"), FPL("\\foo\\bar\\baz") }, true}, | |
| 546 { { FPL("\\foo/bar"), FPL("\\foo/bar/baz") }, true}, | |
| 547 { { FPL("\\"), FPL("\\foo\\bar\\baz") }, true}, | |
| 548 { { FPL(""), FPL("\\foo\\bar\\baz") }, false}, | |
| 549 { { FPL("\\foo\\bar"), FPL("\\foo2\\bar\\baz") }, false}, | |
| 550 { { FPL("\\foo\\bar"), FPL("\\foo\\bar2\\baz") }, false}, | |
| 551 #endif // FILE_PATH_USES_WIN_SEPARATORS | |
| 552 }; | |
| 553 | |
| 554 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 555 FilePath parent(cases[i].inputs[0]); | |
| 556 FilePath child(cases[i].inputs[1]); | |
| 557 | |
| 558 EXPECT_EQ(parent.IsParent(child), cases[i].expected) << | |
| 559 "i: " << i << ", parent: " << parent.value() << ", child: " << | |
| 560 child.value(); | |
| 561 } | |
| 562 } | |
| 563 | |
| 564 TEST_F(FilePathTest, AppendRelativePathTest) { | |
| 565 const struct BinaryTestData cases[] = { | |
| 566 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 567 { { FPL("/"), FPL("/foo/bar/baz") }, FPL("foo\\bar\\baz")}, | |
| 568 #else // FILE_PATH_USES_WIN_SEPARATORS | |
| 569 { { FPL("/"), FPL("/foo/bar/baz") }, FPL("foo/bar/baz")}, | |
| 570 #endif // FILE_PATH_USES_WIN_SEPARATORS | |
| 571 { { FPL("/foo/bar"), FPL("/foo/bar/baz") }, FPL("baz")}, | |
| 572 { { FPL("/foo/bar/"), FPL("/foo/bar/baz") }, FPL("baz")}, | |
| 573 { { FPL("//foo/bar/"), FPL("//foo/bar/baz") }, FPL("baz")}, | |
| 574 { { FPL("/foo/bar"), FPL("/foo2/bar/baz") }, FPL("")}, | |
| 575 { { FPL("/foo/bar.txt"), FPL("/foo/bar/baz") }, FPL("")}, | |
| 576 { { FPL("/foo/bar"), FPL("/foo/bar2/baz") }, FPL("")}, | |
| 577 { { FPL("/foo/bar"), FPL("/foo/bar") }, FPL("")}, | |
| 578 { { FPL("/foo/bar/baz"), FPL("/foo/bar") }, FPL("")}, | |
| 579 { { FPL("foo/bar"), FPL("foo/bar/baz") }, FPL("baz")}, | |
| 580 { { FPL("foo/bar"), FPL("foo2/bar/baz") }, FPL("")}, | |
| 581 { { FPL("foo/bar"), FPL("foo/bar2/baz") }, FPL("")}, | |
| 582 { { FPL(""), FPL("foo") }, FPL("")}, | |
| 583 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 584 { { FPL("c:/foo/bar"), FPL("c:/foo/bar/baz") }, FPL("baz")}, | |
| 585 { { FPL("E:/foo/bar"), FPL("e:/foo/bar/baz") }, FPL("baz")}, | |
| 586 { { FPL("f:/foo/bar"), FPL("F:/foo/bar/baz") }, FPL("baz")}, | |
| 587 { { FPL("E:/Foo/bar"), FPL("e:/foo/bar/baz") }, FPL("")}, | |
| 588 { { FPL("f:/foo/bar"), FPL("F:/foo/Bar/baz") }, FPL("")}, | |
| 589 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 590 { { FPL("c:/"), FPL("c:/foo/bar/baz") }, FPL("foo\\bar\\baz")}, | |
| 591 // TODO(akalin): Figure out how to handle the corner case in the | |
| 592 // commented-out test case below. Appending to an empty path gives | |
| 593 // /foo\bar\baz but appending to a nonempty path "blah" gives | |
| 594 // blah\foo\bar\baz. | |
| 595 // { { FPL("c:"), FPL("c:/foo/bar/baz") }, FPL("foo\\bar\\baz")}, | |
| 596 #endif // FILE_PATH_USES_WIN_SEPARATORS | |
| 597 { { FPL("c:/foo/bar"), FPL("d:/foo/bar/baz") }, FPL("")}, | |
| 598 { { FPL("c:/foo/bar"), FPL("D:/foo/bar/baz") }, FPL("")}, | |
| 599 { { FPL("C:/foo/bar"), FPL("d:/foo/bar/baz") }, FPL("")}, | |
| 600 { { FPL("c:/foo/bar"), FPL("c:/foo2/bar/baz") }, FPL("")}, | |
| 601 { { FPL("e:/foo/bar"), FPL("E:/foo2/bar/baz") }, FPL("")}, | |
| 602 { { FPL("F:/foo/bar"), FPL("f:/foo2/bar/baz") }, FPL("")}, | |
| 603 { { FPL("c:/foo/bar"), FPL("c:/foo/bar2/baz") }, FPL("")}, | |
| 604 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 605 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 606 { { FPL("\\foo\\bar"), FPL("\\foo\\bar\\baz") }, FPL("baz")}, | |
| 607 { { FPL("\\foo/bar"), FPL("\\foo\\bar\\baz") }, FPL("baz")}, | |
| 608 { { FPL("\\foo/bar"), FPL("\\foo/bar/baz") }, FPL("baz")}, | |
| 609 { { FPL("\\"), FPL("\\foo\\bar\\baz") }, FPL("foo\\bar\\baz")}, | |
| 610 { { FPL(""), FPL("\\foo\\bar\\baz") }, FPL("")}, | |
| 611 { { FPL("\\foo\\bar"), FPL("\\foo2\\bar\\baz") }, FPL("")}, | |
| 612 { { FPL("\\foo\\bar"), FPL("\\foo\\bar2\\baz") }, FPL("")}, | |
| 613 #endif // FILE_PATH_USES_WIN_SEPARATORS | |
| 614 }; | |
| 615 | |
| 616 const FilePath base(FPL("blah")); | |
| 617 | |
| 618 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 619 FilePath parent(cases[i].inputs[0]); | |
| 620 FilePath child(cases[i].inputs[1]); | |
| 621 { | |
| 622 FilePath result; | |
| 623 bool success = parent.AppendRelativePath(child, &result); | |
| 624 EXPECT_EQ(cases[i].expected[0] != '\0', success) << | |
| 625 "i: " << i << ", parent: " << parent.value() << ", child: " << | |
| 626 child.value(); | |
| 627 EXPECT_STREQ(cases[i].expected, result.value().c_str()) << | |
| 628 "i: " << i << ", parent: " << parent.value() << ", child: " << | |
| 629 child.value(); | |
| 630 } | |
| 631 { | |
| 632 FilePath result(base); | |
| 633 bool success = parent.AppendRelativePath(child, &result); | |
| 634 EXPECT_EQ(cases[i].expected[0] != '\0', success) << | |
| 635 "i: " << i << ", parent: " << parent.value() << ", child: " << | |
| 636 child.value(); | |
| 637 EXPECT_EQ(base.Append(cases[i].expected).value(), result.value()) << | |
| 638 "i: " << i << ", parent: " << parent.value() << ", child: " << | |
| 639 child.value(); | |
| 640 } | |
| 641 } | |
| 642 } | |
| 643 | |
| 644 TEST_F(FilePathTest, EqualityTest) { | |
| 645 const struct BinaryBooleanTestData cases[] = { | |
| 646 { { FPL("/foo/bar/baz"), FPL("/foo/bar/baz") }, true}, | |
| 647 { { FPL("/foo/bar"), FPL("/foo/bar/baz") }, false}, | |
| 648 { { FPL("/foo/bar/baz"), FPL("/foo/bar") }, false}, | |
| 649 { { FPL("//foo/bar/"), FPL("//foo/bar/") }, true}, | |
| 650 { { FPL("/foo/bar"), FPL("/foo2/bar") }, false}, | |
| 651 { { FPL("/foo/bar.txt"), FPL("/foo/bar") }, false}, | |
| 652 { { FPL("foo/bar"), FPL("foo/bar") }, true}, | |
| 653 { { FPL("foo/bar"), FPL("foo/bar/baz") }, false}, | |
| 654 { { FPL(""), FPL("foo") }, false}, | |
| 655 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 656 { { FPL("c:/foo/bar"), FPL("c:/foo/bar") }, true}, | |
| 657 { { FPL("E:/foo/bar"), FPL("e:/foo/bar") }, true}, | |
| 658 { { FPL("f:/foo/bar"), FPL("F:/foo/bar") }, true}, | |
| 659 { { FPL("E:/Foo/bar"), FPL("e:/foo/bar") }, false}, | |
| 660 { { FPL("f:/foo/bar"), FPL("F:/foo/Bar") }, false}, | |
| 661 { { FPL("c:/"), FPL("c:/") }, true}, | |
| 662 { { FPL("c:"), FPL("c:") }, true}, | |
| 663 { { FPL("c:/foo/bar"), FPL("d:/foo/bar") }, false}, | |
| 664 { { FPL("c:/foo/bar"), FPL("D:/foo/bar") }, false}, | |
| 665 { { FPL("C:/foo/bar"), FPL("d:/foo/bar") }, false}, | |
| 666 { { FPL("c:/foo/bar"), FPL("c:/foo2/bar") }, false}, | |
| 667 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 668 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 669 { { FPL("\\foo\\bar"), FPL("\\foo\\bar") }, true}, | |
| 670 { { FPL("\\foo/bar"), FPL("\\foo/bar") }, true}, | |
| 671 { { FPL("\\foo/bar"), FPL("\\foo\\bar") }, false}, | |
| 672 { { FPL("\\"), FPL("\\") }, true}, | |
| 673 { { FPL("\\"), FPL("/") }, false}, | |
| 674 { { FPL(""), FPL("\\") }, false}, | |
| 675 { { FPL("\\foo\\bar"), FPL("\\foo2\\bar") }, false}, | |
| 676 { { FPL("\\foo\\bar"), FPL("\\foo\\bar2") }, false}, | |
| 677 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 678 { { FPL("c:\\foo\\bar"), FPL("c:\\foo\\bar") }, true}, | |
| 679 { { FPL("E:\\foo\\bar"), FPL("e:\\foo\\bar") }, true}, | |
| 680 { { FPL("f:\\foo\\bar"), FPL("F:\\foo/bar") }, false}, | |
| 681 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 682 #endif // FILE_PATH_USES_WIN_SEPARATORS | |
| 683 }; | |
| 684 | |
| 685 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 686 FilePath a(cases[i].inputs[0]); | |
| 687 FilePath b(cases[i].inputs[1]); | |
| 688 | |
| 689 EXPECT_EQ(a == b, cases[i].expected) << | |
| 690 "equality i: " << i << ", a: " << a.value() << ", b: " << | |
| 691 b.value(); | |
| 692 } | |
| 693 | |
| 694 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 695 FilePath a(cases[i].inputs[0]); | |
| 696 FilePath b(cases[i].inputs[1]); | |
| 697 | |
| 698 EXPECT_EQ(a != b, !cases[i].expected) << | |
| 699 "inequality i: " << i << ", a: " << a.value() << ", b: " << | |
| 700 b.value(); | |
| 701 } | |
| 702 } | |
| 703 | |
| 704 TEST_F(FilePathTest, Extension) { | |
| 705 FilePath base_dir(FILE_PATH_LITERAL("base_dir")); | |
| 706 | |
| 707 FilePath jpg = base_dir.Append(FILE_PATH_LITERAL("foo.jpg")); | |
| 708 EXPECT_EQ(FILE_PATH_LITERAL(".jpg"), jpg.Extension()); | |
| 709 EXPECT_EQ(FILE_PATH_LITERAL(".jpg"), jpg.FinalExtension()); | |
| 710 | |
| 711 FilePath base = jpg.BaseName().RemoveExtension(); | |
| 712 EXPECT_EQ(FILE_PATH_LITERAL("foo"), base.value()); | |
| 713 | |
| 714 FilePath path_no_ext = base_dir.Append(base); | |
| 715 EXPECT_EQ(path_no_ext.value(), jpg.RemoveExtension().value()); | |
| 716 | |
| 717 EXPECT_EQ(path_no_ext.value(), path_no_ext.RemoveExtension().value()); | |
| 718 EXPECT_EQ(FILE_PATH_LITERAL(""), path_no_ext.Extension()); | |
| 719 EXPECT_EQ(FILE_PATH_LITERAL(""), path_no_ext.FinalExtension()); | |
| 720 } | |
| 721 | |
| 722 TEST_F(FilePathTest, Extension2) { | |
| 723 const struct UnaryTestData cases[] = { | |
| 724 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 725 { FPL("C:\\a\\b\\c.ext"), FPL(".ext") }, | |
| 726 { FPL("C:\\a\\b\\c."), FPL(".") }, | |
| 727 { FPL("C:\\a\\b\\c"), FPL("") }, | |
| 728 { FPL("C:\\a\\b\\"), FPL("") }, | |
| 729 { FPL("C:\\a\\b.\\"), FPL(".") }, | |
| 730 { FPL("C:\\a\\b\\c.ext1.ext2"), FPL(".ext2") }, | |
| 731 { FPL("C:\\foo.bar\\\\\\"), FPL(".bar") }, | |
| 732 { FPL("C:\\foo.bar\\.."), FPL("") }, | |
| 733 { FPL("C:\\foo.bar\\..\\\\"), FPL("") }, | |
| 734 #endif | |
| 735 { FPL("/foo/bar/baz.ext"), FPL(".ext") }, | |
| 736 { FPL("/foo/bar/baz."), FPL(".") }, | |
| 737 { FPL("/foo/bar/baz.."), FPL(".") }, | |
| 738 { FPL("/foo/bar/baz"), FPL("") }, | |
| 739 { FPL("/foo/bar/"), FPL("") }, | |
| 740 { FPL("/foo/bar./"), FPL(".") }, | |
| 741 { FPL("/foo/bar/baz.ext1.ext2"), FPL(".ext2") }, | |
| 742 { FPL("/subversion-1.6.12.zip"), FPL(".zip") }, | |
| 743 { FPL("/foo.12345.gz"), FPL(".gz") }, | |
| 744 { FPL("/foo..gz"), FPL(".gz") }, | |
| 745 { FPL("."), FPL("") }, | |
| 746 { FPL(".."), FPL("") }, | |
| 747 { FPL("./foo"), FPL("") }, | |
| 748 { FPL("./foo.ext"), FPL(".ext") }, | |
| 749 { FPL("/foo.ext1/bar.ext2"), FPL(".ext2") }, | |
| 750 { FPL("/foo.bar////"), FPL(".bar") }, | |
| 751 { FPL("/foo.bar/.."), FPL("") }, | |
| 752 { FPL("/foo.bar/..////"), FPL("") }, | |
| 753 { FPL("/foo.1234.luser.js"), FPL(".js") }, | |
| 754 { FPL("/user.js"), FPL(".js") }, | |
| 755 }; | |
| 756 const struct UnaryTestData double_extension_cases[] = { | |
| 757 { FPL("/foo.tar.gz"), FPL(".tar.gz") }, | |
| 758 { FPL("/foo.tar.Z"), FPL(".tar.Z") }, | |
| 759 { FPL("/foo.tar.bz2"), FPL(".tar.bz2") }, | |
| 760 { FPL("/foo.1234.gz"), FPL(".1234.gz") }, | |
| 761 { FPL("/foo.1234.tar.gz"), FPL(".tar.gz") }, | |
| 762 { FPL("/foo.tar.tar.gz"), FPL(".tar.gz") }, | |
| 763 { FPL("/foo.tar.gz.gz"), FPL(".gz.gz") }, | |
| 764 { FPL("/foo.1234.user.js"), FPL(".user.js") }, | |
| 765 { FPL("foo.user.js"), FPL(".user.js") }, | |
| 766 { FPL("/foo.tar.bz"), FPL(".tar.bz") }, | |
| 767 }; | |
| 768 for (unsigned int i = 0; i < arraysize(cases); ++i) { | |
| 769 FilePath path(cases[i].input); | |
| 770 FilePath::StringType extension = path.Extension(); | |
| 771 FilePath::StringType final_extension = path.FinalExtension(); | |
| 772 EXPECT_STREQ(cases[i].expected, extension.c_str()) | |
| 773 << "i: " << i << ", path: " << path.value(); | |
| 774 EXPECT_STREQ(cases[i].expected, final_extension.c_str()) | |
| 775 << "i: " << i << ", path: " << path.value(); | |
| 776 } | |
| 777 for (unsigned int i = 0; i < arraysize(double_extension_cases); ++i) { | |
| 778 FilePath path(double_extension_cases[i].input); | |
| 779 FilePath::StringType extension = path.Extension(); | |
| 780 EXPECT_STREQ(double_extension_cases[i].expected, extension.c_str()) | |
| 781 << "i: " << i << ", path: " << path.value(); | |
| 782 } | |
| 783 } | |
| 784 | |
| 785 TEST_F(FilePathTest, InsertBeforeExtension) { | |
| 786 const struct BinaryTestData cases[] = { | |
| 787 { { FPL(""), FPL("") }, FPL("") }, | |
| 788 { { FPL(""), FPL("txt") }, FPL("") }, | |
| 789 { { FPL("."), FPL("txt") }, FPL("") }, | |
| 790 { { FPL(".."), FPL("txt") }, FPL("") }, | |
| 791 { { FPL("foo.dll"), FPL("txt") }, FPL("footxt.dll") }, | |
| 792 { { FPL("."), FPL("") }, FPL(".") }, | |
| 793 { { FPL("foo.dll"), FPL(".txt") }, FPL("foo.txt.dll") }, | |
| 794 { { FPL("foo"), FPL("txt") }, FPL("footxt") }, | |
| 795 { { FPL("foo"), FPL(".txt") }, FPL("foo.txt") }, | |
| 796 { { FPL("foo.baz.dll"), FPL("txt") }, FPL("foo.baztxt.dll") }, | |
| 797 { { FPL("foo.baz.dll"), FPL(".txt") }, FPL("foo.baz.txt.dll") }, | |
| 798 { { FPL("foo.dll"), FPL("") }, FPL("foo.dll") }, | |
| 799 { { FPL("foo.dll"), FPL(".") }, FPL("foo..dll") }, | |
| 800 { { FPL("foo"), FPL("") }, FPL("foo") }, | |
| 801 { { FPL("foo"), FPL(".") }, FPL("foo.") }, | |
| 802 { { FPL("foo.baz.dll"), FPL("") }, FPL("foo.baz.dll") }, | |
| 803 { { FPL("foo.baz.dll"), FPL(".") }, FPL("foo.baz..dll") }, | |
| 804 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 805 { { FPL("\\"), FPL("") }, FPL("\\") }, | |
| 806 { { FPL("\\"), FPL("txt") }, FPL("\\txt") }, | |
| 807 { { FPL("\\."), FPL("txt") }, FPL("") }, | |
| 808 { { FPL("\\.."), FPL("txt") }, FPL("") }, | |
| 809 { { FPL("\\."), FPL("") }, FPL("\\.") }, | |
| 810 { { FPL("C:\\bar\\foo.dll"), FPL("txt") }, | |
| 811 FPL("C:\\bar\\footxt.dll") }, | |
| 812 { { FPL("C:\\bar.baz\\foodll"), FPL("txt") }, | |
| 813 FPL("C:\\bar.baz\\foodlltxt") }, | |
| 814 { { FPL("C:\\bar.baz\\foo.dll"), FPL("txt") }, | |
| 815 FPL("C:\\bar.baz\\footxt.dll") }, | |
| 816 { { FPL("C:\\bar.baz\\foo.dll.exe"), FPL("txt") }, | |
| 817 FPL("C:\\bar.baz\\foo.dlltxt.exe") }, | |
| 818 { { FPL("C:\\bar.baz\\foo"), FPL("") }, | |
| 819 FPL("C:\\bar.baz\\foo") }, | |
| 820 { { FPL("C:\\bar.baz\\foo.exe"), FPL("") }, | |
| 821 FPL("C:\\bar.baz\\foo.exe") }, | |
| 822 { { FPL("C:\\bar.baz\\foo.dll.exe"), FPL("") }, | |
| 823 FPL("C:\\bar.baz\\foo.dll.exe") }, | |
| 824 { { FPL("C:\\bar\\baz\\foo.exe"), FPL(" (1)") }, | |
| 825 FPL("C:\\bar\\baz\\foo (1).exe") }, | |
| 826 { { FPL("C:\\foo.baz\\\\"), FPL(" (1)") }, FPL("C:\\foo (1).baz") }, | |
| 827 { { FPL("C:\\foo.baz\\..\\"), FPL(" (1)") }, FPL("") }, | |
| 828 #endif | |
| 829 { { FPL("/"), FPL("") }, FPL("/") }, | |
| 830 { { FPL("/"), FPL("txt") }, FPL("/txt") }, | |
| 831 { { FPL("/."), FPL("txt") }, FPL("") }, | |
| 832 { { FPL("/.."), FPL("txt") }, FPL("") }, | |
| 833 { { FPL("/."), FPL("") }, FPL("/.") }, | |
| 834 { { FPL("/bar/foo.dll"), FPL("txt") }, FPL("/bar/footxt.dll") }, | |
| 835 { { FPL("/bar.baz/foodll"), FPL("txt") }, FPL("/bar.baz/foodlltxt") }, | |
| 836 { { FPL("/bar.baz/foo.dll"), FPL("txt") }, FPL("/bar.baz/footxt.dll") }, | |
| 837 { { FPL("/bar.baz/foo.dll.exe"), FPL("txt") }, | |
| 838 FPL("/bar.baz/foo.dlltxt.exe") }, | |
| 839 { { FPL("/bar.baz/foo"), FPL("") }, FPL("/bar.baz/foo") }, | |
| 840 { { FPL("/bar.baz/foo.exe"), FPL("") }, FPL("/bar.baz/foo.exe") }, | |
| 841 { { FPL("/bar.baz/foo.dll.exe"), FPL("") }, FPL("/bar.baz/foo.dll.exe") }, | |
| 842 { { FPL("/bar/baz/foo.exe"), FPL(" (1)") }, FPL("/bar/baz/foo (1).exe") }, | |
| 843 { { FPL("/bar/baz/..////"), FPL(" (1)") }, FPL("") }, | |
| 844 }; | |
| 845 for (unsigned int i = 0; i < arraysize(cases); ++i) { | |
| 846 FilePath path(cases[i].inputs[0]); | |
| 847 FilePath result = path.InsertBeforeExtension(cases[i].inputs[1]); | |
| 848 EXPECT_EQ(cases[i].expected, result.value()) << "i: " << i << | |
| 849 ", path: " << path.value() << ", insert: " << cases[i].inputs[1]; | |
| 850 } | |
| 851 } | |
| 852 | |
| 853 TEST_F(FilePathTest, RemoveExtension) { | |
| 854 const struct UnaryTestData cases[] = { | |
| 855 { FPL(""), FPL("") }, | |
| 856 { FPL("."), FPL(".") }, | |
| 857 { FPL(".."), FPL("..") }, | |
| 858 { FPL("foo.dll"), FPL("foo") }, | |
| 859 { FPL("./foo.dll"), FPL("./foo") }, | |
| 860 { FPL("foo..dll"), FPL("foo.") }, | |
| 861 { FPL("foo"), FPL("foo") }, | |
| 862 { FPL("foo."), FPL("foo") }, | |
| 863 { FPL("foo.."), FPL("foo.") }, | |
| 864 { FPL("foo.baz.dll"), FPL("foo.baz") }, | |
| 865 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 866 { FPL("C:\\foo.bar\\foo"), FPL("C:\\foo.bar\\foo") }, | |
| 867 { FPL("C:\\foo.bar\\..\\\\"), FPL("C:\\foo.bar\\..\\\\") }, | |
| 868 #endif | |
| 869 { FPL("/foo.bar/foo"), FPL("/foo.bar/foo") }, | |
| 870 { FPL("/foo.bar/..////"), FPL("/foo.bar/..////") }, | |
| 871 }; | |
| 872 for (unsigned int i = 0; i < arraysize(cases); ++i) { | |
| 873 FilePath path(cases[i].input); | |
| 874 FilePath removed = path.RemoveExtension(); | |
| 875 FilePath removed_final = path.RemoveFinalExtension(); | |
| 876 EXPECT_EQ(cases[i].expected, removed.value()) << "i: " << i << | |
| 877 ", path: " << path.value(); | |
| 878 EXPECT_EQ(cases[i].expected, removed_final.value()) << "i: " << i << | |
| 879 ", path: " << path.value(); | |
| 880 } | |
| 881 { | |
| 882 FilePath path(FPL("foo.tar.gz")); | |
| 883 FilePath removed = path.RemoveExtension(); | |
| 884 FilePath removed_final = path.RemoveFinalExtension(); | |
| 885 EXPECT_EQ(FPL("foo"), removed.value()) << ", path: " << path.value(); | |
| 886 EXPECT_EQ(FPL("foo.tar"), removed_final.value()) << ", path: " | |
| 887 << path.value(); | |
| 888 } | |
| 889 } | |
| 890 | |
| 891 TEST_F(FilePathTest, ReplaceExtension) { | |
| 892 const struct BinaryTestData cases[] = { | |
| 893 { { FPL(""), FPL("") }, FPL("") }, | |
| 894 { { FPL(""), FPL("txt") }, FPL("") }, | |
| 895 { { FPL("."), FPL("txt") }, FPL("") }, | |
| 896 { { FPL(".."), FPL("txt") }, FPL("") }, | |
| 897 { { FPL("."), FPL("") }, FPL("") }, | |
| 898 { { FPL("foo.dll"), FPL("txt") }, FPL("foo.txt") }, | |
| 899 { { FPL("./foo.dll"), FPL("txt") }, FPL("./foo.txt") }, | |
| 900 { { FPL("foo..dll"), FPL("txt") }, FPL("foo..txt") }, | |
| 901 { { FPL("foo.dll"), FPL(".txt") }, FPL("foo.txt") }, | |
| 902 { { FPL("foo"), FPL("txt") }, FPL("foo.txt") }, | |
| 903 { { FPL("foo."), FPL("txt") }, FPL("foo.txt") }, | |
| 904 { { FPL("foo.."), FPL("txt") }, FPL("foo..txt") }, | |
| 905 { { FPL("foo"), FPL(".txt") }, FPL("foo.txt") }, | |
| 906 { { FPL("foo.baz.dll"), FPL("txt") }, FPL("foo.baz.txt") }, | |
| 907 { { FPL("foo.baz.dll"), FPL(".txt") }, FPL("foo.baz.txt") }, | |
| 908 { { FPL("foo.dll"), FPL("") }, FPL("foo") }, | |
| 909 { { FPL("foo.dll"), FPL(".") }, FPL("foo") }, | |
| 910 { { FPL("foo"), FPL("") }, FPL("foo") }, | |
| 911 { { FPL("foo"), FPL(".") }, FPL("foo") }, | |
| 912 { { FPL("foo.baz.dll"), FPL("") }, FPL("foo.baz") }, | |
| 913 { { FPL("foo.baz.dll"), FPL(".") }, FPL("foo.baz") }, | |
| 914 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 915 { { FPL("C:\\foo.bar\\foo"), FPL("baz") }, FPL("C:\\foo.bar\\foo.baz") }, | |
| 916 { { FPL("C:\\foo.bar\\..\\\\"), FPL("baz") }, FPL("") }, | |
| 917 #endif | |
| 918 { { FPL("/foo.bar/foo"), FPL("baz") }, FPL("/foo.bar/foo.baz") }, | |
| 919 { { FPL("/foo.bar/..////"), FPL("baz") }, FPL("") }, | |
| 920 }; | |
| 921 for (unsigned int i = 0; i < arraysize(cases); ++i) { | |
| 922 FilePath path(cases[i].inputs[0]); | |
| 923 FilePath replaced = path.ReplaceExtension(cases[i].inputs[1]); | |
| 924 EXPECT_EQ(cases[i].expected, replaced.value()) << "i: " << i << | |
| 925 ", path: " << path.value() << ", replace: " << cases[i].inputs[1]; | |
| 926 } | |
| 927 } | |
| 928 | |
| 929 TEST_F(FilePathTest, AddExtension) { | |
| 930 const struct BinaryTestData cases[] = { | |
| 931 { { FPL(""), FPL("") }, FPL("") }, | |
| 932 { { FPL(""), FPL("txt") }, FPL("") }, | |
| 933 { { FPL("."), FPL("txt") }, FPL("") }, | |
| 934 { { FPL(".."), FPL("txt") }, FPL("") }, | |
| 935 { { FPL("."), FPL("") }, FPL("") }, | |
| 936 { { FPL("foo.dll"), FPL("txt") }, FPL("foo.dll.txt") }, | |
| 937 { { FPL("./foo.dll"), FPL("txt") }, FPL("./foo.dll.txt") }, | |
| 938 { { FPL("foo..dll"), FPL("txt") }, FPL("foo..dll.txt") }, | |
| 939 { { FPL("foo.dll"), FPL(".txt") }, FPL("foo.dll.txt") }, | |
| 940 { { FPL("foo"), FPL("txt") }, FPL("foo.txt") }, | |
| 941 { { FPL("foo."), FPL("txt") }, FPL("foo.txt") }, | |
| 942 { { FPL("foo.."), FPL("txt") }, FPL("foo..txt") }, | |
| 943 { { FPL("foo"), FPL(".txt") }, FPL("foo.txt") }, | |
| 944 { { FPL("foo.baz.dll"), FPL("txt") }, FPL("foo.baz.dll.txt") }, | |
| 945 { { FPL("foo.baz.dll"), FPL(".txt") }, FPL("foo.baz.dll.txt") }, | |
| 946 { { FPL("foo.dll"), FPL("") }, FPL("foo.dll") }, | |
| 947 { { FPL("foo.dll"), FPL(".") }, FPL("foo.dll") }, | |
| 948 { { FPL("foo"), FPL("") }, FPL("foo") }, | |
| 949 { { FPL("foo"), FPL(".") }, FPL("foo") }, | |
| 950 { { FPL("foo.baz.dll"), FPL("") }, FPL("foo.baz.dll") }, | |
| 951 { { FPL("foo.baz.dll"), FPL(".") }, FPL("foo.baz.dll") }, | |
| 952 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 953 { { FPL("C:\\foo.bar\\foo"), FPL("baz") }, FPL("C:\\foo.bar\\foo.baz") }, | |
| 954 { { FPL("C:\\foo.bar\\..\\\\"), FPL("baz") }, FPL("") }, | |
| 955 #endif | |
| 956 { { FPL("/foo.bar/foo"), FPL("baz") }, FPL("/foo.bar/foo.baz") }, | |
| 957 { { FPL("/foo.bar/..////"), FPL("baz") }, FPL("") }, | |
| 958 }; | |
| 959 for (unsigned int i = 0; i < arraysize(cases); ++i) { | |
| 960 FilePath path(cases[i].inputs[0]); | |
| 961 FilePath added = path.AddExtension(cases[i].inputs[1]); | |
| 962 EXPECT_EQ(cases[i].expected, added.value()) << "i: " << i << | |
| 963 ", path: " << path.value() << ", add: " << cases[i].inputs[1]; | |
| 964 } | |
| 965 } | |
| 966 | |
| 967 TEST_F(FilePathTest, MatchesExtension) { | |
| 968 const struct BinaryBooleanTestData cases[] = { | |
| 969 { { FPL("foo"), FPL("") }, true}, | |
| 970 { { FPL("foo"), FPL(".") }, false}, | |
| 971 { { FPL("foo."), FPL("") }, false}, | |
| 972 { { FPL("foo."), FPL(".") }, true}, | |
| 973 { { FPL("foo.txt"), FPL(".dll") }, false}, | |
| 974 { { FPL("foo.txt"), FPL(".txt") }, true}, | |
| 975 { { FPL("foo.txt.dll"), FPL(".txt") }, false}, | |
| 976 { { FPL("foo.txt.dll"), FPL(".dll") }, true}, | |
| 977 { { FPL("foo.TXT"), FPL(".txt") }, true}, | |
| 978 { { FPL("foo.txt"), FPL(".TXT") }, true}, | |
| 979 { { FPL("foo.tXt"), FPL(".txt") }, true}, | |
| 980 { { FPL("foo.txt"), FPL(".tXt") }, true}, | |
| 981 { { FPL("foo.tXt"), FPL(".TXT") }, true}, | |
| 982 { { FPL("foo.tXt"), FPL(".tXt") }, true}, | |
| 983 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | |
| 984 { { FPL("c:/foo.txt.dll"), FPL(".txt") }, false}, | |
| 985 { { FPL("c:/foo.txt"), FPL(".txt") }, true}, | |
| 986 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 987 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 988 { { FPL("c:\\bar\\foo.txt.dll"), FPL(".txt") }, false}, | |
| 989 { { FPL("c:\\bar\\foo.txt"), FPL(".txt") }, true}, | |
| 990 #endif // FILE_PATH_USES_DRIVE_LETTERS | |
| 991 { { FPL("/bar/foo.txt.dll"), FPL(".txt") }, false}, | |
| 992 { { FPL("/bar/foo.txt"), FPL(".txt") }, true}, | |
| 993 #if defined(OS_WIN) || defined(OS_MACOSX) | |
| 994 // Umlauts A, O, U: direct comparison, and upper case vs. lower case | |
| 995 { { FPL("foo.\u00E4\u00F6\u00FC"), FPL(".\u00E4\u00F6\u00FC") }, true}, | |
| 996 { { FPL("foo.\u00C4\u00D6\u00DC"), FPL(".\u00E4\u00F6\u00FC") }, true}, | |
| 997 // C with circumflex: direct comparison, and upper case vs. lower case | |
| 998 { { FPL("foo.\u0109"), FPL(".\u0109") }, true}, | |
| 999 { { FPL("foo.\u0108"), FPL(".\u0109") }, true}, | |
| 1000 #endif | |
| 1001 }; | |
| 1002 | |
| 1003 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 1004 FilePath path(cases[i].inputs[0]); | |
| 1005 FilePath::StringType ext(cases[i].inputs[1]); | |
| 1006 | |
| 1007 EXPECT_EQ(cases[i].expected, path.MatchesExtension(ext)) << | |
| 1008 "i: " << i << ", path: " << path.value() << ", ext: " << ext; | |
| 1009 } | |
| 1010 } | |
| 1011 | |
| 1012 TEST_F(FilePathTest, CompareIgnoreCase) { | |
| 1013 const struct BinaryIntTestData cases[] = { | |
| 1014 { { FPL("foo"), FPL("foo") }, 0}, | |
| 1015 { { FPL("FOO"), FPL("foo") }, 0}, | |
| 1016 { { FPL("foo.ext"), FPL("foo.ext") }, 0}, | |
| 1017 { { FPL("FOO.EXT"), FPL("foo.ext") }, 0}, | |
| 1018 { { FPL("Foo.Ext"), FPL("foo.ext") }, 0}, | |
| 1019 { { FPL("foO"), FPL("foo") }, 0}, | |
| 1020 { { FPL("foo"), FPL("foO") }, 0}, | |
| 1021 { { FPL("fOo"), FPL("foo") }, 0}, | |
| 1022 { { FPL("foo"), FPL("fOo") }, 0}, | |
| 1023 { { FPL("bar"), FPL("foo") }, -1}, | |
| 1024 { { FPL("foo"), FPL("bar") }, 1}, | |
| 1025 { { FPL("BAR"), FPL("foo") }, -1}, | |
| 1026 { { FPL("FOO"), FPL("bar") }, 1}, | |
| 1027 { { FPL("bar"), FPL("FOO") }, -1}, | |
| 1028 { { FPL("foo"), FPL("BAR") }, 1}, | |
| 1029 { { FPL("BAR"), FPL("FOO") }, -1}, | |
| 1030 { { FPL("FOO"), FPL("BAR") }, 1}, | |
| 1031 // German "Eszett" (lower case and the new-fangled upper case) | |
| 1032 // Note that uc(<lowercase eszett>) => "SS", NOT <uppercase eszett>! | |
| 1033 // However, neither Windows nor Mac OSX converts these. | |
| 1034 // (or even have glyphs for <uppercase eszett>) | |
| 1035 { { FPL("\u00DF"), FPL("\u00DF") }, 0}, | |
| 1036 { { FPL("\u1E9E"), FPL("\u1E9E") }, 0}, | |
| 1037 { { FPL("\u00DF"), FPL("\u1E9E") }, -1}, | |
| 1038 { { FPL("SS"), FPL("\u00DF") }, -1}, | |
| 1039 { { FPL("SS"), FPL("\u1E9E") }, -1}, | |
| 1040 #if defined(OS_WIN) || defined(OS_MACOSX) | |
| 1041 // Umlauts A, O, U: direct comparison, and upper case vs. lower case | |
| 1042 { { FPL("\u00E4\u00F6\u00FC"), FPL("\u00E4\u00F6\u00FC") }, 0}, | |
| 1043 { { FPL("\u00C4\u00D6\u00DC"), FPL("\u00E4\u00F6\u00FC") }, 0}, | |
| 1044 // C with circumflex: direct comparison, and upper case vs. lower case | |
| 1045 { { FPL("\u0109"), FPL("\u0109") }, 0}, | |
| 1046 { { FPL("\u0108"), FPL("\u0109") }, 0}, | |
| 1047 // Cyrillic letter SHA: direct comparison, and upper case vs. lower case | |
| 1048 { { FPL("\u0428"), FPL("\u0428") }, 0}, | |
| 1049 { { FPL("\u0428"), FPL("\u0448") }, 0}, | |
| 1050 // Greek letter DELTA: direct comparison, and upper case vs. lower case | |
| 1051 { { FPL("\u0394"), FPL("\u0394") }, 0}, | |
| 1052 { { FPL("\u0394"), FPL("\u03B4") }, 0}, | |
| 1053 // Japanese full-width A: direct comparison, and upper case vs. lower case | |
| 1054 // Note that full-width and standard characters are considered different. | |
| 1055 { { FPL("\uFF21"), FPL("\uFF21") }, 0}, | |
| 1056 { { FPL("\uFF21"), FPL("\uFF41") }, 0}, | |
| 1057 { { FPL("A"), FPL("\uFF21") }, -1}, | |
| 1058 { { FPL("A"), FPL("\uFF41") }, -1}, | |
| 1059 { { FPL("a"), FPL("\uFF21") }, -1}, | |
| 1060 { { FPL("a"), FPL("\uFF41") }, -1}, | |
| 1061 #endif | |
| 1062 #if defined(OS_MACOSX) | |
| 1063 // Codepoints > 0x1000 | |
| 1064 // Georgian letter DON: direct comparison, and upper case vs. lower case | |
| 1065 { { FPL("\u10A3"), FPL("\u10A3") }, 0}, | |
| 1066 { { FPL("\u10A3"), FPL("\u10D3") }, 0}, | |
| 1067 // Combining characters vs. pre-composed characters, upper and lower case | |
| 1068 { { FPL("k\u0301u\u032Do\u0304\u0301n"), FPL("\u1E31\u1E77\u1E53n") }, 0}, | |
| 1069 { { FPL("k\u0301u\u032Do\u0304\u0301n"), FPL("kuon") }, 1}, | |
| 1070 { { FPL("kuon"), FPL("k\u0301u\u032Do\u0304\u0301n") }, -1}, | |
| 1071 { { FPL("K\u0301U\u032DO\u0304\u0301N"), FPL("KUON") }, 1}, | |
| 1072 { { FPL("KUON"), FPL("K\u0301U\u032DO\u0304\u0301N") }, -1}, | |
| 1073 { { FPL("k\u0301u\u032Do\u0304\u0301n"), FPL("KUON") }, 1}, | |
| 1074 { { FPL("K\u0301U\u032DO\u0304\u0301N"), FPL("\u1E31\u1E77\u1E53n") }, 0}, | |
| 1075 { { FPL("k\u0301u\u032Do\u0304\u0301n"), FPL("\u1E30\u1E76\u1E52n") }, 0}, | |
| 1076 { { FPL("k\u0301u\u032Do\u0304\u0302n"), FPL("\u1E30\u1E76\u1E52n") }, 1}, | |
| 1077 #endif | |
| 1078 }; | |
| 1079 | |
| 1080 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 1081 FilePath::StringType s1(cases[i].inputs[0]); | |
| 1082 FilePath::StringType s2(cases[i].inputs[1]); | |
| 1083 int result = FilePath::CompareIgnoreCase(s1, s2); | |
| 1084 EXPECT_EQ(cases[i].expected, result) << | |
| 1085 "i: " << i << ", s1: " << s1 << ", s2: " << s2; | |
| 1086 } | |
| 1087 } | |
| 1088 | |
| 1089 TEST_F(FilePathTest, ReferencesParent) { | |
| 1090 const struct UnaryBooleanTestData cases[] = { | |
| 1091 { FPL("."), false }, | |
| 1092 { FPL(".."), true }, | |
| 1093 { FPL(".. "), true }, | |
| 1094 { FPL(" .."), true }, | |
| 1095 { FPL("..."), true }, | |
| 1096 { FPL("a.."), false }, | |
| 1097 { FPL("..a"), false }, | |
| 1098 { FPL("../"), true }, | |
| 1099 { FPL("/.."), true }, | |
| 1100 { FPL("/../"), true }, | |
| 1101 { FPL("/a../"), false }, | |
| 1102 { FPL("/..a/"), false }, | |
| 1103 { FPL("//.."), true }, | |
| 1104 { FPL("..//"), true }, | |
| 1105 { FPL("//..//"), true }, | |
| 1106 { FPL("a//..//c"), true }, | |
| 1107 { FPL("../b/c"), true }, | |
| 1108 { FPL("/../b/c"), true }, | |
| 1109 { FPL("a/b/.."), true }, | |
| 1110 { FPL("a/b/../"), true }, | |
| 1111 { FPL("a/../c"), true }, | |
| 1112 { FPL("a/b/c"), false }, | |
| 1113 }; | |
| 1114 | |
| 1115 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 1116 FilePath input(cases[i].input); | |
| 1117 bool observed = input.ReferencesParent(); | |
| 1118 EXPECT_EQ(cases[i].expected, observed) << | |
| 1119 "i: " << i << ", input: " << input.value(); | |
| 1120 } | |
| 1121 } | |
| 1122 | |
| 1123 TEST_F(FilePathTest, FromUTF8Unsafe_And_AsUTF8Unsafe) { | |
| 1124 const struct UTF8TestData cases[] = { | |
| 1125 { FPL("foo.txt"), "foo.txt" }, | |
| 1126 // "aeo" with accents. Use http://0xcc.net/jsescape/ to decode them. | |
| 1127 { FPL("\u00E0\u00E8\u00F2.txt"), "\xC3\xA0\xC3\xA8\xC3\xB2.txt" }, | |
| 1128 // Full-width "ABC". | |
| 1129 { FPL("\uFF21\uFF22\uFF23.txt"), | |
| 1130 "\xEF\xBC\xA1\xEF\xBC\xA2\xEF\xBC\xA3.txt" }, | |
| 1131 }; | |
| 1132 | |
| 1133 #if !defined(SYSTEM_NATIVE_UTF8) && defined(OS_LINUX) | |
| 1134 ScopedLocale locale("en_US.UTF-8"); | |
| 1135 #endif | |
| 1136 | |
| 1137 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 1138 // Test FromUTF8Unsafe() works. | |
| 1139 FilePath from_utf8 = FilePath::FromUTF8Unsafe(cases[i].utf8); | |
| 1140 EXPECT_EQ(cases[i].native, from_utf8.value()) | |
| 1141 << "i: " << i << ", input: " << cases[i].native; | |
| 1142 // Test AsUTF8Unsafe() works. | |
| 1143 FilePath from_native = FilePath(cases[i].native); | |
| 1144 EXPECT_EQ(cases[i].utf8, from_native.AsUTF8Unsafe()) | |
| 1145 << "i: " << i << ", input: " << cases[i].native; | |
| 1146 // Test the two file paths are identical. | |
| 1147 EXPECT_EQ(from_utf8.value(), from_native.value()); | |
| 1148 } | |
| 1149 } | |
| 1150 | |
| 1151 TEST_F(FilePathTest, ConstructWithNUL) { | |
| 1152 // Assert FPS() works. | |
| 1153 ASSERT_EQ(3U, FPS("a\0b").length()); | |
| 1154 | |
| 1155 // Test constructor strips '\0' | |
| 1156 FilePath path(FPS("a\0b")); | |
| 1157 EXPECT_EQ(1U, path.value().length()); | |
| 1158 EXPECT_EQ(FPL("a"), path.value()); | |
| 1159 } | |
| 1160 | |
| 1161 TEST_F(FilePathTest, AppendWithNUL) { | |
| 1162 // Assert FPS() works. | |
| 1163 ASSERT_EQ(3U, FPS("b\0b").length()); | |
| 1164 | |
| 1165 // Test Append() strips '\0' | |
| 1166 FilePath path(FPL("a")); | |
| 1167 path = path.Append(FPS("b\0b")); | |
| 1168 EXPECT_EQ(3U, path.value().length()); | |
| 1169 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 1170 EXPECT_EQ(FPL("a\\b"), path.value()); | |
| 1171 #else | |
| 1172 EXPECT_EQ(FPL("a/b"), path.value()); | |
| 1173 #endif | |
| 1174 } | |
| 1175 | |
| 1176 TEST_F(FilePathTest, ReferencesParentWithNUL) { | |
| 1177 // Assert FPS() works. | |
| 1178 ASSERT_EQ(3U, FPS("..\0").length()); | |
| 1179 | |
| 1180 // Test ReferencesParent() doesn't break with "..\0" | |
| 1181 FilePath path(FPS("..\0")); | |
| 1182 EXPECT_TRUE(path.ReferencesParent()); | |
| 1183 } | |
| 1184 | |
| 1185 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | |
| 1186 TEST_F(FilePathTest, NormalizePathSeparators) { | |
| 1187 const struct UnaryTestData cases[] = { | |
| 1188 { FPL("foo/bar"), FPL("foo\\bar") }, | |
| 1189 { FPL("foo/bar\\betz"), FPL("foo\\bar\\betz") }, | |
| 1190 { FPL("foo\\bar"), FPL("foo\\bar") }, | |
| 1191 { FPL("foo\\bar/betz"), FPL("foo\\bar\\betz") }, | |
| 1192 { FPL("foo"), FPL("foo") }, | |
| 1193 // Trailing slashes don't automatically get stripped. That's what | |
| 1194 // StripTrailingSeparators() is for. | |
| 1195 { FPL("foo\\"), FPL("foo\\") }, | |
| 1196 { FPL("foo/"), FPL("foo\\") }, | |
| 1197 { FPL("foo/bar\\"), FPL("foo\\bar\\") }, | |
| 1198 { FPL("foo\\bar/"), FPL("foo\\bar\\") }, | |
| 1199 { FPL("foo/bar/"), FPL("foo\\bar\\") }, | |
| 1200 { FPL("foo\\bar\\"), FPL("foo\\bar\\") }, | |
| 1201 { FPL("\\foo/bar"), FPL("\\foo\\bar") }, | |
| 1202 { FPL("/foo\\bar"), FPL("\\foo\\bar") }, | |
| 1203 { FPL("c:/foo/bar/"), FPL("c:\\foo\\bar\\") }, | |
| 1204 { FPL("/foo/bar/"), FPL("\\foo\\bar\\") }, | |
| 1205 { FPL("\\foo\\bar\\"), FPL("\\foo\\bar\\") }, | |
| 1206 { FPL("c:\\foo/bar"), FPL("c:\\foo\\bar") }, | |
| 1207 { FPL("//foo\\bar\\"), FPL("\\\\foo\\bar\\") }, | |
| 1208 { FPL("\\\\foo\\bar\\"), FPL("\\\\foo\\bar\\") }, | |
| 1209 { FPL("//foo\\bar\\"), FPL("\\\\foo\\bar\\") }, | |
| 1210 // This method does not normalize the number of path separators. | |
| 1211 { FPL("foo\\\\bar"), FPL("foo\\\\bar") }, | |
| 1212 { FPL("foo//bar"), FPL("foo\\\\bar") }, | |
| 1213 { FPL("foo/\\bar"), FPL("foo\\\\bar") }, | |
| 1214 { FPL("foo\\/bar"), FPL("foo\\\\bar") }, | |
| 1215 { FPL("///foo\\\\bar"), FPL("\\\\\\foo\\\\bar") }, | |
| 1216 { FPL("foo//bar///"), FPL("foo\\\\bar\\\\\\") }, | |
| 1217 { FPL("foo/\\bar/\\"), FPL("foo\\\\bar\\\\") }, | |
| 1218 { FPL("/\\foo\\/bar"), FPL("\\\\foo\\\\bar") }, | |
| 1219 }; | |
| 1220 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 1221 FilePath input(cases[i].input); | |
| 1222 FilePath observed = input.NormalizePathSeparators(); | |
| 1223 EXPECT_EQ(FilePath::StringType(cases[i].expected), observed.value()) << | |
| 1224 "i: " << i << ", input: " << input.value(); | |
| 1225 } | |
| 1226 } | |
| 1227 #endif | |
| 1228 | |
| 1229 TEST_F(FilePathTest, EndsWithSeparator) { | |
| 1230 const UnaryBooleanTestData cases[] = { | |
| 1231 { FPL(""), false }, | |
| 1232 { FPL("/"), true }, | |
| 1233 { FPL("foo/"), true }, | |
| 1234 { FPL("bar"), false }, | |
| 1235 { FPL("/foo/bar"), false }, | |
| 1236 }; | |
| 1237 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 1238 FilePath input = FilePath(cases[i].input).NormalizePathSeparators(); | |
| 1239 EXPECT_EQ(cases[i].expected, input.EndsWithSeparator()); | |
| 1240 } | |
| 1241 } | |
| 1242 | |
| 1243 TEST_F(FilePathTest, AsEndingWithSeparator) { | |
| 1244 const UnaryTestData cases[] = { | |
| 1245 { FPL(""), FPL("") }, | |
| 1246 { FPL("/"), FPL("/") }, | |
| 1247 { FPL("foo"), FPL("foo/") }, | |
| 1248 { FPL("foo/"), FPL("foo/") } | |
| 1249 }; | |
| 1250 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 1251 FilePath input = FilePath(cases[i].input).NormalizePathSeparators(); | |
| 1252 FilePath expected = FilePath(cases[i].expected).NormalizePathSeparators(); | |
| 1253 EXPECT_EQ(expected.value(), input.AsEndingWithSeparator().value()); | |
| 1254 } | |
| 1255 } | |
| 1256 | |
| 1257 #if defined(OS_ANDROID) | |
| 1258 TEST_F(FilePathTest, ContentUriTest) { | |
| 1259 const struct UnaryBooleanTestData cases[] = { | |
| 1260 { FPL("content://foo.bar"), true }, | |
| 1261 { FPL("content://foo.bar/"), true }, | |
| 1262 { FPL("content://foo/bar"), true }, | |
| 1263 { FPL("CoNTenT://foo.bar"), true }, | |
| 1264 { FPL("content://"), true }, | |
| 1265 { FPL("content:///foo.bar"), true }, | |
| 1266 { FPL("content://3foo/bar"), true }, | |
| 1267 { FPL("content://_foo/bar"), true }, | |
| 1268 { FPL(".. "), false }, | |
| 1269 { FPL("foo.bar"), false }, | |
| 1270 { FPL("content:foo.bar"), false }, | |
| 1271 { FPL("content:/foo.ba"), false }, | |
| 1272 { FPL("content:/dir/foo.bar"), false }, | |
| 1273 { FPL("content: //foo.bar"), false }, | |
| 1274 { FPL("content%2a%2f%2f"), false }, | |
| 1275 }; | |
| 1276 | |
| 1277 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 1278 FilePath input(cases[i].input); | |
| 1279 bool observed = input.IsContentUri(); | |
| 1280 EXPECT_EQ(cases[i].expected, observed) << | |
| 1281 "i: " << i << ", input: " << input.value(); | |
| 1282 } | |
| 1283 } | |
| 1284 #endif | |
| 1285 | |
| 1286 // Test the PrintTo overload for FilePath (used when a test fails to compare two | |
| 1287 // FilePaths). | |
| 1288 TEST_F(FilePathTest, PrintTo) { | |
| 1289 std::stringstream ss; | |
| 1290 FilePath fp(FPL("foo")); | |
| 1291 base::PrintTo(fp, &ss); | |
| 1292 EXPECT_EQ("foo", ss.str()); | |
| 1293 } | |
| 1294 | |
| 1295 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
