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