unittests/tests/PathTest.cpp

   1 #include <muleunit/test.h>
   2
   3 #include <common/Path.h>
   4 #include <common/StringFunctions.h>
   5
   6 #include <wx/filename.h>
   7
   8 using namespace muleunit;
   9
  10 #if 0
  11 /*
  12  * The validity of this test is at least questionable. The result depends on
  13  * - the current system locale and character encoding used, and
  14  * - the way wxConvFileName reports error conditions and its fallback behaviour.
  15
  16 struct STestStr
  17 {
  18         //! Specifies the "source" of the string (user/fs)
  19         const bool fromFS;
  20         //! Input filename
  21         const wxString input;
  22         //! The expected result.
  23         const wxString expected;
  24 };
  25
  26 const STestStr g_fromFSTests[] = {
  27         // From filesystem
  28         { true, wxConvFileName->cMB2WC("\xe1\x62\x63"), wxT("\xe1\x62\x63") },
  29         { true, wxConvFileName->cMB2WC("\xe6\xf8\xe5"), wxT("\xe6\xf8\xe5") },
  30         { true, wxConvFileName->cMB2WC("\xd8\xa7\xd9\x84\xd8\xb9"), wxT("\u0627\u0644\u0639") },
  31
  32         // From User
  33         { false, wxT("\u0627\u0644\u0639"), wxT("\u0627\u0644\u0639") }
  34 };
  35
  36 enum UsesEncoding {
  37         UE_Unknown,
  38         UE_Broken,
  39         UE_NonBroken
  40 };
  41
  42 wxString GetExpectedString(const wxString& src)
  43 {
  44         // Determine how the filenames are expected to be mangled
  45         static UsesEncoding encoding = UE_Unknown;
  46
  47         if (encoding == UE_Unknown) {
  48                 wxCharBuffer fn = wxConvFile.cWC2MB(wxT("\u0627\u0644\u0639"));
  49
  50                 if (fn) {
  51                         encoding = UE_NonBroken;
  52                 } else {
  53                         encoding = UE_Broken;
  54                 }
  55         }
  56
  57         if ((encoding == UE_Broken) && !wxConvFile.cWC2MB(src)) {
  58                 // See CPath::CPath for rationale ...
  59                 wxCharBuffer fn = wxConvUTF8.cWC2MB(src);
  60                 return wxConvFile.cMB2WC(fn);
  61         } else {
  62                 return src;
  63         }
  64 }
  65 */
  66 #endif
  67
  68 wxString StringFrom(const CPath& prt)
  69 {
  70         return prt.GetPrintable();
  71 }
  72
  73
  74 DECLARE_SIMPLE(GenericPathFunctions)
  75
  76 TEST(GenericPathFunctions, JoinPaths)
  77 {
  78         const wxString seps = wxFileName::GetPathSeparators();
  79         const wxString sep = wxFileName::GetPathSeparator();
  80
  81         for (size_t i = 0; i < seps.Length(); ++i) {
  82                 const wxString cur_sep = seps.Mid(i, 1);
  83
  84                 ASSERT_EQUALS(wxT("a") + sep + wxT("b"), JoinPaths(wxT("a"), wxT("b")));
  85                 ASSERT_EQUALS(wxT("a") + sep + wxT("b"), JoinPaths(wxT("a") + cur_sep, wxT("b")));
  86                 ASSERT_EQUALS(wxT("a") + sep + wxT("b"), JoinPaths(wxT("a"), cur_sep + wxT("b")));
  87                 ASSERT_EQUALS(wxT("a") + sep + wxT("b"), JoinPaths(wxT("a") + cur_sep, cur_sep + wxT("b")));
  88                 ASSERT_EQUALS(wxT("a"), JoinPaths(wxT("a"), wxEmptyString));
  89                 ASSERT_EQUALS(wxT("b"), JoinPaths(wxEmptyString, wxT("b")));
  90                 ASSERT_EQUALS(wxEmptyString, JoinPaths(wxEmptyString, wxEmptyString));
  91         }
  92 }
  93
  94
  95 DECLARE_SIMPLE(CPath)
  96
  97 TEST(CPath, DefaultConstructor)
  98 {
  99         CPath tmp;
 100
 101         ASSERT_FALSE(tmp.IsOk());
 102         ASSERT_EQUALS(tmp, CPath());
 103
 104         ASSERT_FALSE(tmp.FileExists());
 105         ASSERT_FALSE(tmp.DirExists());
 106
 107         ASSERT_EQUALS(wxEmptyString, tmp.GetRaw());
 108         ASSERT_EQUALS(wxEmptyString, tmp.GetPrintable());
 109         ASSERT_EQUALS(CPath(), tmp.GetPath());
 110         ASSERT_EQUALS(CPath(), tmp.GetFullName());
 111 }
 112
 113
 114 TEST(CPath, PathConstructor)
 115 {
 116         {
 117                 CPath tmp(wxT(""));
 118
 119                 ASSERT_FALSE(tmp.IsOk());
 120                 ASSERT_EQUALS(tmp, CPath());
 121         }
 122
 123 #if 0
 124 /*
 125  * See the note above
 126
 127         for (size_t i = 0; i < ArraySize(g_fromFSTests); ++i) {
 128                 const wxString input = g_fromFSTests[i].input;
 129                 const wxString result = g_fromFSTests[i].expected;
 130
 131                 ASSERT_TRUE(result.Length());
 132                 ASSERT_TRUE(input.Length());
 133
 134                 CPath tmp(input);
 135
 136                 ASSERT_TRUE(tmp.IsOk());
 137                 ASSERT_EQUALS(tmp, CPath(input));
 138
 139                 ASSERT_EQUALS(tmp.GetRaw(), ::GetExpectedString(input));
 140                 ASSERT_EQUALS(tmp.GetPrintable(), result);
 141
 142                 ASSERT_EQUALS(tmp.GetFullName(), tmp);
 143                 ASSERT_EQUALS(tmp.GetPath(), CPath());
 144         }
 145 */
 146 #endif
 147 }
 148
 149
 150 TEST(CPath, CopyConstructor)
 151 {
 152         const wxChar* tmpPath = wxT("foobar.tgz");
 153
 154         {
 155                 CPath a(tmpPath);
 156
 157                 ASSERT_TRUE(a.IsOk());
 158                 ASSERT_EQUALS(a.GetRaw(), tmpPath);
 159                 ASSERT_EQUALS(a.GetPrintable(), tmpPath);
 160                 ASSERT_EQUALS(a.GetPath(), CPath());
 161                 ASSERT_EQUALS(a.GetFullName(), CPath(tmpPath));
 162
 163                 CPath b(a);
 164                 ASSERT_TRUE(b.IsOk());
 165                 ASSERT_EQUALS(b.GetRaw(), tmpPath);
 166                 ASSERT_EQUALS(b.GetPrintable(), tmpPath);
 167                 ASSERT_EQUALS(b.GetPath(), CPath());
 168                 ASSERT_EQUALS(b.GetFullName(), CPath(tmpPath));
 169
 170                 ASSERT_EQUALS(a, b);
 171         }
 172
 173         {
 174                 CPath a(tmpPath);
 175
 176                 ASSERT_TRUE(a.IsOk());
 177                 ASSERT_EQUALS(a.GetRaw(), tmpPath);
 178                 ASSERT_EQUALS(a.GetPrintable(), tmpPath);
 179                 ASSERT_EQUALS(a.GetPath(), CPath());
 180                 ASSERT_EQUALS(a.GetFullName(), CPath(tmpPath));
 181
 182                 CPath b(a);
 183                 ASSERT_TRUE(b.IsOk());
 184                 ASSERT_EQUALS(b.GetRaw(), tmpPath);
 185                 ASSERT_EQUALS(b.GetPrintable(), tmpPath);
 186                 ASSERT_EQUALS(b.GetPath(), CPath());
 187                 ASSERT_EQUALS(b.GetFullName(), CPath(tmpPath));
 188
 189                 ASSERT_EQUALS(a, b);
 190         }
 191
 192         {
 193                 CPath a;
 194                 CPath b(a);
 195
 196                 ASSERT_EQUALS(a, b);
 197                 ASSERT_FALSE(a.IsOk());
 198                 ASSERT_FALSE(b.IsOk());
 199         }
 200 }
 201
 202
 203 TEST(CPath, Operators)
 204 {
 205         const wxChar* tmpPath1 = wxT("foobar.tgz");
 206         const wxChar* tmpPath2 = wxT("barfoo.tar");
 207
 208         {
 209                 CPath a, b;
 210                 ASSERT_EQUALS(a, b);
 211                 ASSERT_FALSE(a.IsOk());
 212                 ASSERT_FALSE(b.IsOk());
 213
 214                 a = CPath(tmpPath1);
 215                 ASSERT_EQUALS(a.GetRaw(), tmpPath1);
 216                 ASSERT_EQUALS(a.GetPrintable(), tmpPath1);
 217                 ASSERT_EQUALS(a.GetPath(), CPath());
 218                 ASSERT_EQUALS(a.GetFullName(), CPath(tmpPath1));
 219                 ASSERT_TRUE(a.IsOk());
 220                 ASSERT_TRUE(a != b);
 221
 222                 b = a;
 223                 ASSERT_EQUALS(b.GetRaw(), tmpPath1);
 224                 ASSERT_EQUALS(b.GetPrintable(), tmpPath1);
 225                 ASSERT_EQUALS(b.GetPath(), CPath());
 226                 ASSERT_EQUALS(b.GetFullName(), CPath(tmpPath1));
 227                 ASSERT_TRUE(a.IsOk());
 228                 ASSERT_TRUE(b.IsOk());
 229                 ASSERT_EQUALS(a, b);
 230
 231                 a = CPath(tmpPath2);
 232                 ASSERT_TRUE(a.IsOk());
 233                 ASSERT_TRUE(b.IsOk());
 234                 ASSERT_TRUE(a != b);
 235
 236                 ASSERT_EQUALS(a.GetRaw(), tmpPath2);
 237                 ASSERT_EQUALS(a.GetPrintable(), tmpPath2);
 238                 ASSERT_EQUALS(a.GetPath(), CPath());
 239                 ASSERT_EQUALS(a.GetFullName(), CPath(tmpPath2));
 240                 ASSERT_EQUALS(b.GetRaw(), tmpPath1);
 241                 ASSERT_EQUALS(b.GetPrintable(), tmpPath1);
 242                 ASSERT_EQUALS(b.GetPath(), CPath());
 243                 ASSERT_EQUALS(b.GetFullName(), CPath(tmpPath1));
 244         }
 245
 246 // See note in CPath::operator==
 247 #if 0
 248         {
 249                 CPath a = CPath(wxT("/home/amule"));
 250                 CPath b = CPath(wxT("/hone/amule/"));
 251
 252                 ASSERT_EQUALS(a, b);
 253         }
 254 #endif
 255
 256         // TODO: Less than
 257 }
 258
 259
 260 /** Return the path normalized for the current platform. */
 261 CPath Norm(wxString str)
 262 {
 263         str.Replace(wxT("/"), wxString(wxFileName::GetPathSeparator()));
 264
 265         return CPath(str);
 266 }
 267
 268
 269 TEST(CPath, JoinPaths)
 270 {
 271         const CPath expected1 = Norm(wxT("/home/amule/"));
 272         const CPath expected2 = Norm(wxT("/home/amule"));
 273
 274         // Note: Just a few checks, as ::JoinPaths is tested above
 275         ASSERT_EQUALS(expected1, Norm(wxT("/home")).JoinPaths(Norm(wxT("amule/"))));
 276         ASSERT_EQUALS(expected1, Norm(wxT("/home")).JoinPaths(Norm(wxT("/amule/"))));
 277         ASSERT_EQUALS(expected1, Norm(wxT("/home/")).JoinPaths(Norm(wxT("/amule/"))));
 278         ASSERT_EQUALS(expected1, Norm(wxT("/home/")).JoinPaths(Norm(wxT("amule/"))));
 279
 280         ASSERT_EQUALS(expected2, Norm(wxT("/home")).JoinPaths(Norm(wxT("amule"))));
 281         ASSERT_EQUALS(expected2, Norm(wxT("/home")).JoinPaths(Norm(wxT("/amule"))));
 282         ASSERT_EQUALS(expected2, Norm(wxT("/home/")).JoinPaths(Norm(wxT("/amule"))));
 283         ASSERT_EQUALS(expected2, Norm(wxT("/home/")).JoinPaths(Norm(wxT("amule"))));
 284
 285         ASSERT_EQUALS(expected1, expected1.JoinPaths(CPath()));
 286         ASSERT_EQUALS(expected1, CPath().JoinPaths(expected1));
 287
 288         ASSERT_EQUALS(expected2, expected2.JoinPaths(CPath()));
 289         ASSERT_EQUALS(expected2, CPath().JoinPaths(expected2));
 290 }
 291
 292
 293 TEST(CPath, StartsWith)
 294 {
 295         const CPath test = Norm(wxT("/home/amule/"));
 296
 297         ASSERT_FALSE(test.StartsWith(CPath()));
 298         ASSERT_FALSE(CPath().StartsWith(test));
 299
 300         ASSERT_TRUE(test.StartsWith(Norm(wxT("/"))));
 301         ASSERT_TRUE(test.StartsWith(Norm(wxT("/home"))));
 302         ASSERT_TRUE(test.StartsWith(Norm(wxT("/home/"))));
 303         ASSERT_TRUE(test.StartsWith(Norm(wxT("/home/amule"))));
 304         ASSERT_TRUE(test.StartsWith(Norm(wxT("/home/amule/"))));
 305
 306         ASSERT_FALSE(test.StartsWith(Norm(wxT(""))));
 307         ASSERT_FALSE(test.StartsWith(Norm(wxT("~"))));
 308         ASSERT_FALSE(test.StartsWith(Norm(wxT("/ho"))));
 309         ASSERT_FALSE(test.StartsWith(Norm(wxT("/home/am"))));
 310         ASSERT_FALSE(test.StartsWith(Norm(wxT("/home/amule2"))));
 311         ASSERT_FALSE(test.StartsWith(Norm(wxT("/home/amule/foo"))));
 312 }
 313
 314
 315 TEST(CPath, IsSameDir)
 316 {
 317         ASSERT_TRUE(Norm(wxT("/root")).IsSameDir(Norm(wxT("/root"))));
 318         ASSERT_TRUE(Norm(wxT("/root/")).IsSameDir(Norm(wxT("/root"))));
 319         ASSERT_TRUE(Norm(wxT("/root")).IsSameDir(Norm(wxT("/root/"))));
 320         ASSERT_TRUE(Norm(wxT("/root/")).IsSameDir(Norm(wxT("/root/"))));
 321
 322         ASSERT_FALSE(CPath().IsSameDir(Norm(wxT("/"))));
 323         ASSERT_FALSE(Norm(wxT("/")).IsSameDir(CPath()));
 324
 325         ASSERT_FALSE(Norm(wxT("/root")).IsSameDir(Norm(wxT("/home"))));
 326 }
 327
 328
 329 TEST(CPath, GetPath_FullName)
 330 {
 331         {
 332                 ASSERT_EQUALS(CPath().GetPath(), CPath());
 333                 ASSERT_EQUALS(CPath().GetFullName(), CPath());
 334         }
 335
 336         {
 337                 const CPath path = Norm(wxT("/home/mule/"));
 338
 339                 ASSERT_EQUALS(path.GetPath(), Norm(wxT("/home/mule")));
 340                 ASSERT_EQUALS(path.GetFullName(), CPath());
 341         }
 342
 343         {
 344                 const CPath path = Norm(wxT("/home/mule"));
 345
 346                 ASSERT_EQUALS(path.GetPath(), Norm(wxT("/home")));
 347                 ASSERT_EQUALS(path.GetFullName(), Norm(wxT("mule")));
 348         }
 349
 350         {
 351                 const CPath path = Norm(wxT("mule"));
 352
 353                 ASSERT_EQUALS(path.GetPath(), CPath());
 354                 ASSERT_EQUALS(path.GetFullName(), Norm(wxT("mule")));
 355         }
 356
 357         {
 358                 const CPath path = Norm(wxT("mule.ext"));
 359
 360                 ASSERT_EQUALS(path.GetPath(), CPath());
 361                 ASSERT_EQUALS(path.GetFullName(), Norm(wxT("mule.ext")));
 362         }
 363 }
 364
 365
 366 TEST(CPath, Cleanup)
 367 {
 368         const CPath initial = CPath(wxT(" /a\"b*c* <d>?e|\\:f "));
 369
 370         ASSERT_EQUALS(initial.Cleanup(false, false), Norm(wxT("\%20a\"b*c*\%20<d>?e|\\:f\%20")));
 371         ASSERT_EQUALS(initial.Cleanup(false, true), Norm(wxT("\%20abc\%20def\%20")));
 372         ASSERT_EQUALS(initial.Cleanup(true, false), Norm(wxT(" a\"b*c* <d>?e|\\:f ")));
 373         ASSERT_EQUALS(initial.Cleanup(true, true), Norm(wxT(" abc def ")));
 374 }
 375
 376
 377 TEST(CPath, AddPostFix)
 378 {
 379         ASSERT_EQUALS(Norm(wxT("/foo.bar")).AddPostfix(wxT("_1")), Norm(wxT("/foo_1.bar")));
 380         ASSERT_EQUALS(Norm(wxT("/foo.bar")).AddPostfix(wxT("")), Norm(wxT("/foo.bar")));
 381         ASSERT_EQUALS(Norm(wxT("/.bar")).AddPostfix(wxT("_1")), Norm(wxT("/.bar_1")));
 382         ASSERT_EQUALS(Norm(wxT("/")).AddPostfix(wxT("_1")), Norm(wxT("/_1")));
 383 }
 384
 385
 386 TEST(CPath, Extensions)
 387 {
 388         const CPath initial = Norm(wxT("/home/amule.foo.bar"));
 389
 390         ASSERT_EQUALS(Norm(wxT("/home/amule.foo")), initial.RemoveExt());
 391         ASSERT_EQUALS(Norm(wxT("/home/amule")), initial.RemoveExt().RemoveExt());
 392         ASSERT_EQUALS(Norm(wxT("/home/amule")), initial.RemoveExt().RemoveExt().RemoveExt());
 393         ASSERT_EQUALS(Norm(wxT("/home/amule")), initial.RemoveAllExt());
 394
 395         ASSERT_EQUALS(wxT("bar"), initial.GetExt());
 396         ASSERT_EQUALS(wxT("foo"), initial.RemoveExt().GetExt());
 397         ASSERT_EQUALS(wxEmptyString, initial.RemoveExt().RemoveExt().GetExt());
 398         ASSERT_EQUALS(wxEmptyString, initial.RemoveAllExt().GetExt());
 399
 400         ASSERT_EQUALS(Norm(wxT("/home/amule.foo.bar")), initial.AppendExt(wxT("")));
 401         ASSERT_EQUALS(Norm(wxT("/home/amule.foo.bar.zod")), initial.AppendExt(wxT("zod")));
 402         ASSERT_EQUALS(Norm(wxT("/home/amule.foo.bar.zod")), initial.AppendExt(wxT(".zod")));
 403         ASSERT_EQUALS(Norm(wxT("/home/amule.zod")), initial.RemoveAllExt().AppendExt(wxT("zod")));
 404         ASSERT_EQUALS(Norm(wxT("/home/amule.zod")), initial.RemoveAllExt().AppendExt(wxT(".zod")));
 405 }
 406
 407 TEST(CPath, TruncatePath)
 408 {
 409         const CPath testPath = Norm(wxT("/home/amule/truncate"));
 410
 411         ASSERT_EQUALS(Norm(wxT("/home/amule/truncate")).GetPrintable(), testPath.TruncatePath(21));
 412         ASSERT_EQUALS(Norm(wxT("/home/amule/truncate")).GetPrintable(), testPath.TruncatePath(20));
 413         ASSERT_EQUALS(Norm(wxT("/home/amule/tr[...]")).GetPrintable(), testPath.TruncatePath(19));
 414         ASSERT_EQUALS(Norm(wxT("/h[...]")).GetPrintable(), testPath.TruncatePath(7));
 415         ASSERT_EQUALS(Norm(wxT("/[...]")).GetPrintable(), testPath.TruncatePath(6));
 416         ASSERT_EQUALS(wxEmptyString, testPath.TruncatePath(5));
 417         ASSERT_EQUALS(wxEmptyString, testPath.TruncatePath(4));
 418
 419         ASSERT_EQUALS(Norm(wxT("/home/amule/truncate")).GetPrintable(), testPath.TruncatePath(21, true));
 420         ASSERT_EQUALS(Norm(wxT("/home/amule/truncate")).GetPrintable(), testPath.TruncatePath(20, true));
 421         ASSERT_EQUALS(Norm(wxT("[...]amule/truncate")).GetPrintable(), testPath.TruncatePath(19, true));
 422         ASSERT_EQUALS(Norm(wxT("[...]e/truncate")).GetPrintable(), testPath.TruncatePath(15, true));
 423         ASSERT_EQUALS(wxT("truncate"), testPath.TruncatePath(14, true));
 424         ASSERT_EQUALS(wxT("truncate"), testPath.TruncatePath(13, true));
 425         ASSERT_EQUALS(wxT("truncate"), testPath.TruncatePath(9, true));
 426         ASSERT_EQUALS(wxT("truncate"), testPath.TruncatePath(8, true));
 427         ASSERT_EQUALS(wxT("tr[...]"), testPath.TruncatePath(7, true));
 428         ASSERT_EQUALS(wxT("t[...]"), testPath.TruncatePath(6, true));
 429         ASSERT_EQUALS(wxEmptyString, testPath.TruncatePath(5, true));
 430 }