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(CPath(input), tmp);
 138
 139                 ASSERT_EQUALS(::GetExpectedString(input), tmp.GetRaw());
 140                 ASSERT_EQUALS(result, tmp.GetPrintable());
 141
 142                 ASSERT_EQUALS(tmp, tmp.GetFullName());
 143                 ASSERT_EQUALS(CPath(), tmp.GetPath());
 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(tmpPath, a.GetRaw());
 159                 ASSERT_EQUALS(tmpPath, a.GetPrintable());
 160                 ASSERT_EQUALS(CPath(), a.GetPath());
 161                 ASSERT_EQUALS(CPath(tmpPath), a.GetFullName());
 162
 163                 CPath b(a);
 164                 ASSERT_TRUE(b.IsOk());
 165                 ASSERT_EQUALS(tmpPath, b.GetRaw());
 166                 ASSERT_EQUALS(tmpPath, b.GetPrintable());
 167                 ASSERT_EQUALS(CPath(), b.GetPath());
 168                 ASSERT_EQUALS(CPath(tmpPath), b.GetFullName());
 169
 170                 ASSERT_EQUALS(a, b);
 171         }
 172
 173         {
 174                 CPath a;
 175                 CPath b(a);
 176
 177                 ASSERT_EQUALS(a, b);
 178                 ASSERT_FALSE(a.IsOk());
 179                 ASSERT_FALSE(b.IsOk());
 180         }
 181 }
 182
 183
 184 TEST(CPath, Operators)
 185 {
 186         const wxChar* tmpPath1 = wxT("foobar.tgz");
 187         const wxChar* tmpPath2 = wxT("barfoo.tar");
 188
 189         {
 190                 CPath a, b;
 191                 ASSERT_EQUALS(a, b);
 192                 ASSERT_FALSE(a.IsOk());
 193                 ASSERT_FALSE(b.IsOk());
 194
 195                 a = CPath(tmpPath1);
 196                 ASSERT_EQUALS(tmpPath1, a.GetRaw());
 197                 ASSERT_EQUALS(tmpPath1, a.GetPrintable());
 198                 ASSERT_EQUALS(CPath(), a.GetPath());
 199                 ASSERT_EQUALS(CPath(tmpPath1), a.GetFullName());
 200                 ASSERT_TRUE(a.IsOk());
 201                 ASSERT_TRUE(a != b);
 202
 203                 b = a;
 204                 ASSERT_EQUALS(tmpPath1, b.GetRaw());
 205                 ASSERT_EQUALS(tmpPath1, b.GetPrintable());
 206                 ASSERT_EQUALS(CPath(), b.GetPath());
 207                 ASSERT_EQUALS(CPath(tmpPath1), b.GetFullName());
 208                 ASSERT_TRUE(a.IsOk());
 209                 ASSERT_TRUE(b.IsOk());
 210                 ASSERT_EQUALS(a, b);
 211
 212                 a = CPath(tmpPath2);
 213                 ASSERT_TRUE(a.IsOk());
 214                 ASSERT_TRUE(b.IsOk());
 215                 ASSERT_TRUE(a != b);
 216
 217                 ASSERT_EQUALS(tmpPath2, a.GetRaw());
 218                 ASSERT_EQUALS(tmpPath2, a.GetPrintable());
 219                 ASSERT_EQUALS(CPath(), a.GetPath());
 220                 ASSERT_EQUALS(CPath(tmpPath2), a.GetFullName());
 221                 ASSERT_EQUALS(tmpPath1, b.GetRaw());
 222                 ASSERT_EQUALS(tmpPath1, b.GetPrintable());
 223                 ASSERT_EQUALS(CPath(), b.GetPath());
 224                 ASSERT_EQUALS(CPath(tmpPath1), b.GetFullName());
 225         }
 226
 227 // See note in CPath::operator==
 228 #if 0
 229         {
 230                 CPath a = CPath(wxT("/home/amule"));
 231                 CPath b = CPath(wxT("/hone/amule/"));
 232
 233                 ASSERT_EQUALS(a, b);
 234         }
 235 #endif
 236
 237         // TODO: Less than
 238 }
 239
 240
 241 /** Return the path normalized for the current platform. */
 242 CPath Norm(wxString str)
 243 {
 244         str.Replace(wxT("/"), wxString(wxFileName::GetPathSeparator()));
 245
 246         return CPath(str);
 247 }
 248
 249
 250 TEST(CPath, JoinPaths)
 251 {
 252         const CPath expected1 = Norm(wxT("/home/amule/"));
 253         const CPath expected2 = Norm(wxT("/home/amule"));
 254
 255         // Note: Just a few checks, as ::JoinPaths is tested above
 256         ASSERT_EQUALS(expected1, Norm(wxT("/home")).JoinPaths(Norm(wxT("amule/"))));
 257         ASSERT_EQUALS(expected1, Norm(wxT("/home")).JoinPaths(Norm(wxT("/amule/"))));
 258         ASSERT_EQUALS(expected1, Norm(wxT("/home/")).JoinPaths(Norm(wxT("/amule/"))));
 259         ASSERT_EQUALS(expected1, Norm(wxT("/home/")).JoinPaths(Norm(wxT("amule/"))));
 260
 261         ASSERT_EQUALS(expected2, Norm(wxT("/home")).JoinPaths(Norm(wxT("amule"))));
 262         ASSERT_EQUALS(expected2, Norm(wxT("/home")).JoinPaths(Norm(wxT("/amule"))));
 263         ASSERT_EQUALS(expected2, Norm(wxT("/home/")).JoinPaths(Norm(wxT("/amule"))));
 264         ASSERT_EQUALS(expected2, Norm(wxT("/home/")).JoinPaths(Norm(wxT("amule"))));
 265
 266         ASSERT_EQUALS(expected1, expected1.JoinPaths(CPath()));
 267         ASSERT_EQUALS(expected1, CPath().JoinPaths(expected1));
 268
 269         ASSERT_EQUALS(expected2, expected2.JoinPaths(CPath()));
 270         ASSERT_EQUALS(expected2, CPath().JoinPaths(expected2));
 271 }
 272
 273
 274 TEST(CPath, StartsWith)
 275 {
 276         const CPath test = Norm(wxT("/home/amule/"));
 277
 278         ASSERT_FALSE(test.StartsWith(CPath()));
 279         ASSERT_FALSE(CPath().StartsWith(test));
 280
 281         ASSERT_TRUE(test.StartsWith(Norm(wxT("/"))));
 282         ASSERT_TRUE(test.StartsWith(Norm(wxT("/home"))));
 283         ASSERT_TRUE(test.StartsWith(Norm(wxT("/home/"))));
 284         ASSERT_TRUE(test.StartsWith(Norm(wxT("/home/amule"))));
 285         ASSERT_TRUE(test.StartsWith(Norm(wxT("/home/amule/"))));
 286
 287         ASSERT_FALSE(test.StartsWith(Norm(wxT(""))));
 288         ASSERT_FALSE(test.StartsWith(Norm(wxT("~"))));
 289         ASSERT_FALSE(test.StartsWith(Norm(wxT("/ho"))));
 290         ASSERT_FALSE(test.StartsWith(Norm(wxT("/home/am"))));
 291         ASSERT_FALSE(test.StartsWith(Norm(wxT("/home/amule2"))));
 292         ASSERT_FALSE(test.StartsWith(Norm(wxT("/home/amule/foo"))));
 293 }
 294
 295
 296 TEST(CPath, IsSameDir)
 297 {
 298         ASSERT_TRUE(Norm(wxT("/root")).IsSameDir(Norm(wxT("/root"))));
 299         ASSERT_TRUE(Norm(wxT("/root/")).IsSameDir(Norm(wxT("/root"))));
 300         ASSERT_TRUE(Norm(wxT("/root")).IsSameDir(Norm(wxT("/root/"))));
 301         ASSERT_TRUE(Norm(wxT("/root/")).IsSameDir(Norm(wxT("/root/"))));
 302
 303         ASSERT_FALSE(CPath().IsSameDir(Norm(wxT("/"))));
 304         ASSERT_FALSE(Norm(wxT("/")).IsSameDir(CPath()));
 305
 306         ASSERT_FALSE(Norm(wxT("/root")).IsSameDir(Norm(wxT("/home"))));
 307 }
 308
 309
 310 TEST(CPath, GetPath_FullName)
 311 {
 312         {
 313                 ASSERT_EQUALS(CPath(), CPath().GetPath());
 314                 ASSERT_EQUALS(CPath(), CPath().GetFullName());
 315         }
 316
 317         {
 318                 const CPath path = Norm(wxT("/home/mule/"));
 319
 320                 ASSERT_EQUALS(Norm(wxT("/home/mule")), path.GetPath());
 321                 ASSERT_EQUALS(CPath(), path.GetFullName());
 322         }
 323
 324         {
 325                 const CPath path = Norm(wxT("/home/mule"));
 326
 327                 ASSERT_EQUALS(Norm(wxT("/home")), path.GetPath());
 328                 ASSERT_EQUALS(Norm(wxT("mule")), path.GetFullName());
 329         }
 330
 331         {
 332                 const CPath path = Norm(wxT("mule"));
 333
 334                 ASSERT_EQUALS(CPath(), path.GetPath());
 335                 ASSERT_EQUALS(Norm(wxT("mule")), path.GetFullName());
 336         }
 337
 338         {
 339                 const CPath path = Norm(wxT("mule.ext"));
 340
 341                 ASSERT_EQUALS(CPath(), path.GetPath());
 342                 ASSERT_EQUALS(Norm(wxT("mule.ext")), path.GetFullName());
 343         }
 344 }
 345
 346
 347 TEST(CPath, Cleanup)
 348 {
 349         const CPath initial = CPath(wxT(" /a\"b*c* <d>?e|\\:f "));
 350
 351         ASSERT_EQUALS(Norm(wxT("\%20a\"b*c*\%20<d>?e|\\:f\%20")), initial.Cleanup(false, false));
 352         ASSERT_EQUALS(Norm(wxT("\%20abc\%20def\%20")), initial.Cleanup(false, true));
 353         ASSERT_EQUALS(Norm(wxT(" a\"b*c* <d>?e|\\:f ")), initial.Cleanup(true, false));
 354         ASSERT_EQUALS(Norm(wxT(" abc def ")), initial.Cleanup(true, true));
 355 }
 356
 357
 358 TEST(CPath, AddPostFix)
 359 {
 360         ASSERT_EQUALS(Norm(wxT("/foo_1.bar")), Norm(wxT("/foo.bar")).AddPostfix(wxT("_1")));
 361         ASSERT_EQUALS(Norm(wxT("/foo.bar")), Norm(wxT("/foo.bar")).AddPostfix(wxT("")));
 362         ASSERT_EQUALS(Norm(wxT("/.bar_1")), Norm(wxT("/.bar")).AddPostfix(wxT("_1")));
 363         ASSERT_EQUALS(Norm(wxT("/_1")), Norm(wxT("/")).AddPostfix(wxT("_1")));
 364 }
 365
 366
 367 TEST(CPath, Extensions)
 368 {
 369         const CPath initial = Norm(wxT("/home/amule.foo.bar"));
 370
 371         ASSERT_EQUALS(Norm(wxT("/home/amule.foo")), initial.RemoveExt());
 372         ASSERT_EQUALS(Norm(wxT("/home/amule")), initial.RemoveExt().RemoveExt());
 373         ASSERT_EQUALS(Norm(wxT("/home/amule")), initial.RemoveExt().RemoveExt().RemoveExt());
 374         ASSERT_EQUALS(Norm(wxT("/home/amule")), initial.RemoveAllExt());
 375
 376         ASSERT_EQUALS(wxT("bar"), initial.GetExt());
 377         ASSERT_EQUALS(wxT("foo"), initial.RemoveExt().GetExt());
 378         ASSERT_EQUALS(wxEmptyString, initial.RemoveExt().RemoveExt().GetExt());
 379         ASSERT_EQUALS(wxEmptyString, initial.RemoveAllExt().GetExt());
 380
 381         ASSERT_EQUALS(Norm(wxT("/home/amule.foo.bar")), initial.AppendExt(wxT("")));
 382         ASSERT_EQUALS(Norm(wxT("/home/amule.foo.bar.zod")), initial.AppendExt(wxT("zod")));
 383         ASSERT_EQUALS(Norm(wxT("/home/amule.foo.bar.zod")), initial.AppendExt(wxT(".zod")));
 384         ASSERT_EQUALS(Norm(wxT("/home/amule.zod")), initial.RemoveAllExt().AppendExt(wxT("zod")));
 385         ASSERT_EQUALS(Norm(wxT("/home/amule.zod")), initial.RemoveAllExt().AppendExt(wxT(".zod")));
 386 }
 387
 388 TEST(CPath, TruncatePath)
 389 {
 390         const CPath testPath = Norm(wxT("/home/amule/truncate"));
 391
 392         ASSERT_EQUALS(Norm(wxT("/home/amule/truncate")).GetPrintable(), testPath.TruncatePath(21));
 393         ASSERT_EQUALS(Norm(wxT("/home/amule/truncate")).GetPrintable(), testPath.TruncatePath(20));
 394         ASSERT_EQUALS(Norm(wxT("/home/amule/tr[...]")).GetPrintable(), testPath.TruncatePath(19));
 395         ASSERT_EQUALS(Norm(wxT("/h[...]")).GetPrintable(), testPath.TruncatePath(7));
 396         ASSERT_EQUALS(Norm(wxT("/[...]")).GetPrintable(), testPath.TruncatePath(6));
 397         ASSERT_EQUALS(wxEmptyString, testPath.TruncatePath(5));
 398         ASSERT_EQUALS(wxEmptyString, testPath.TruncatePath(4));
 399
 400         ASSERT_EQUALS(Norm(wxT("/home/amule/truncate")).GetPrintable(), testPath.TruncatePath(21, true));
 401         ASSERT_EQUALS(Norm(wxT("/home/amule/truncate")).GetPrintable(), testPath.TruncatePath(20, true));
 402         ASSERT_EQUALS(Norm(wxT("[...]amule/truncate")).GetPrintable(), testPath.TruncatePath(19, true));
 403         ASSERT_EQUALS(Norm(wxT("[...]e/truncate")).GetPrintable(), testPath.TruncatePath(15, true));
 404         ASSERT_EQUALS(wxT("truncate"), testPath.TruncatePath(14, true));
 405         ASSERT_EQUALS(wxT("truncate"), testPath.TruncatePath(13, true));
 406         ASSERT_EQUALS(wxT("truncate"), testPath.TruncatePath(9, true));
 407         ASSERT_EQUALS(wxT("truncate"), testPath.TruncatePath(8, true));
 408         ASSERT_EQUALS(wxT("tr[...]"), testPath.TruncatePath(7, true));
 409         ASSERT_EQUALS(wxT("t[...]"), testPath.TruncatePath(6, true));
 410         ASSERT_EQUALS(wxEmptyString, testPath.TruncatePath(5, true));
 411 }