code.vuplus.com Git - vuplus_xbmc/blob - xbmc/utils/test/TestURIUtils.cpp

   1 /*
   2  *      Copyright (C) 2005-2013 Team XBMC
   3  *      http://xbmc.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with XBMC; see the file COPYING.  If not, see
  17  *  <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "utils/URIUtils.h"
  22 #include "settings/AdvancedSettings.h"
  23 #include "URL.h"
  24
  25 #include "gtest/gtest.h"
  26
  27 class TestURIUtils : public testing::Test
  28 {
  29 protected:
  30   TestURIUtils(){}
  31   ~TestURIUtils()
  32   {
  33     g_advancedSettings.m_pathSubstitutions.clear();
  34   }
  35 };
  36
  37 TEST_F(TestURIUtils, IsInPath)
  38 {
  39   EXPECT_TRUE(URIUtils::IsInPath("/path/to/movie.avi", "/path/to/"));
  40   EXPECT_FALSE(URIUtils::IsInPath("/path/to/movie.avi", "/path/2/"));
  41 }
  42
  43 TEST_F(TestURIUtils, GetDirectory)
  44 {
  45   EXPECT_STREQ("/path/to/", URIUtils::GetDirectory("/path/to/movie.avi"));
  46   EXPECT_STREQ("/path/to/", URIUtils::GetDirectory("/path/to/"));
  47   EXPECT_STREQ("/path/to/|option=foo", URIUtils::GetDirectory("/path/to/movie.avi|option=foo"));
  48   EXPECT_STREQ("/path/to/|option=foo", URIUtils::GetDirectory("/path/to/|option=foo"));
  49   EXPECT_STREQ("", URIUtils::GetDirectory("movie.avi"));
  50   EXPECT_STREQ("", URIUtils::GetDirectory("movie.avi|option=foo"));
  51   EXPECT_STREQ("", URIUtils::GetDirectory(""));
  52
  53   // Make sure it works when assigning to the same str as the reference parameter
  54   CStdString var = "/path/to/movie.avi|option=foo";
  55   var = URIUtils::GetDirectory(var);
  56   EXPECT_STREQ("/path/to/|option=foo", var);
  57 }
  58
  59 TEST_F(TestURIUtils, GetExtension)
  60 {
  61   EXPECT_STREQ(".avi",
  62                URIUtils::GetExtension("/path/to/movie.avi").c_str());
  63 }
  64
  65 TEST_F(TestURIUtils, HasExtension)
  66 {
  67   EXPECT_TRUE (URIUtils::HasExtension("/path/to/movie.AvI"));
  68   EXPECT_FALSE(URIUtils::HasExtension("/path/to/movie"));
  69   EXPECT_FALSE(URIUtils::HasExtension("/path/.to/movie"));
  70   EXPECT_FALSE(URIUtils::HasExtension(""));
  71
  72   EXPECT_TRUE (URIUtils::HasExtension("/path/to/movie.AvI", ".avi"));
  73   EXPECT_FALSE(URIUtils::HasExtension("/path/to/movie.AvI", ".mkv"));
  74   EXPECT_FALSE(URIUtils::HasExtension("/path/.avi/movie", ".avi"));
  75   EXPECT_FALSE(URIUtils::HasExtension("", ".avi"));
  76
  77   EXPECT_TRUE (URIUtils::HasExtension("/path/movie.AvI", ".avi|.mkv|.mp4"));
  78   EXPECT_TRUE (URIUtils::HasExtension("/path/movie.AvI", ".mkv|.avi|.mp4"));
  79   EXPECT_FALSE(URIUtils::HasExtension("/path/movie.AvI", ".mpg|.mkv|.mp4"));
  80   EXPECT_FALSE(URIUtils::HasExtension("/path.mkv/movie.AvI", ".mpg|.mkv|.mp4"));
  81   EXPECT_FALSE(URIUtils::HasExtension("", ".avi|.mkv|.mp4"));
  82 }
  83
  84 TEST_F(TestURIUtils, GetFileName)
  85 {
  86   EXPECT_STREQ("movie.avi",
  87                URIUtils::GetFileName("/path/to/movie.avi").c_str());
  88 }
  89
  90 TEST_F(TestURIUtils, RemoveExtension)
  91 {
  92   CStdString ref, var;
  93
  94   /* NOTE: CSettings need to be set to find other extensions. */
  95   ref = "/path/to/file";
  96   var = "/path/to/file.xml";
  97   URIUtils::RemoveExtension(var);
  98   EXPECT_STREQ(ref.c_str(), var.c_str());
  99 }
 100
 101 TEST_F(TestURIUtils, ReplaceExtension)
 102 {
 103   CStdString ref, var;
 104
 105   ref = "/path/to/file.xsd";
 106   var = URIUtils::ReplaceExtension("/path/to/file.xml", ".xsd");
 107   EXPECT_STREQ(ref.c_str(), var.c_str());
 108 }
 109
 110 TEST_F(TestURIUtils, Split)
 111 {
 112   CStdString refpath, reffile, varpath, varfile;
 113
 114   refpath = "/path/to/";
 115   reffile = "movie.avi";
 116   URIUtils::Split("/path/to/movie.avi", varpath, varfile);
 117   EXPECT_STREQ(refpath.c_str(), varpath.c_str());
 118   EXPECT_STREQ(reffile.c_str(), varfile.c_str());
 119 }
 120
 121 TEST_F(TestURIUtils, SplitPath)
 122 {
 123   CStdStringArray strarray;
 124
 125   strarray = URIUtils::SplitPath("http://www.test.com/path/to/movie.avi");
 126
 127   EXPECT_STREQ("http://www.test.com/", strarray.at(0).c_str());
 128   EXPECT_STREQ("path", strarray.at(1).c_str());
 129   EXPECT_STREQ("to", strarray.at(2).c_str());
 130   EXPECT_STREQ("movie.avi", strarray.at(3).c_str());
 131 }
 132
 133 TEST_F(TestURIUtils, SplitPathLocal)
 134 {
 135 #ifndef TARGET_LINUX
 136   const char *path = "C:\\path\\to\\movie.avi";
 137 #else
 138   const char *path = "/path/to/movie.avi";
 139 #endif
 140   CStdStringArray strarray;
 141
 142   strarray = URIUtils::SplitPath(path);
 143
 144 #ifndef TARGET_LINUX
 145   EXPECT_STREQ("C:", strarray.at(0).c_str());
 146 #else
 147   EXPECT_STREQ("", strarray.at(0).c_str());
 148 #endif
 149   EXPECT_STREQ("path", strarray.at(1).c_str());
 150   EXPECT_STREQ("to", strarray.at(2).c_str());
 151   EXPECT_STREQ("movie.avi", strarray.at(3).c_str());
 152 }
 153
 154 TEST_F(TestURIUtils, GetCommonPath)
 155 {
 156   CStdString ref, var;
 157
 158   ref = "/path/";
 159   var = "/path/2/movie.avi";
 160   URIUtils::GetCommonPath(var, "/path/to/movie.avi");
 161   EXPECT_STREQ(ref.c_str(), var.c_str());
 162 }
 163
 164 TEST_F(TestURIUtils, GetParentPath)
 165 {
 166   CStdString ref, var;
 167
 168   ref = "/path/to/";
 169   var = URIUtils::GetParentPath("/path/to/movie.avi");
 170   EXPECT_STREQ(ref.c_str(), var.c_str());
 171
 172   var.clear();
 173   EXPECT_TRUE(URIUtils::GetParentPath("/path/to/movie.avi", var));
 174   EXPECT_STREQ(ref.c_str(), var.c_str());
 175 }
 176
 177 TEST_F(TestURIUtils, SubstitutePath)
 178 {
 179   CStdString from, to, ref, var;
 180
 181   from = "C:\\My Videos";
 182   to = "https://myserver/some%20other%20path";
 183   g_advancedSettings.m_pathSubstitutions.push_back(std::make_pair(from, to));
 184
 185   from = "/this/path1";
 186   to = "/some/other/path2";
 187   g_advancedSettings.m_pathSubstitutions.push_back(std::make_pair(from, to));
 188
 189   from = "davs://otherserver/my%20music%20path";
 190   to = "D:\\Local Music\\MP3 Collection";
 191   g_advancedSettings.m_pathSubstitutions.push_back(std::make_pair(from, to));
 192
 193   ref = "https://myserver/some%20other%20path/sub%20dir/movie%20name.avi";
 194   var = URIUtils::SubstitutePath("C:\\My Videos\\sub dir\\movie name.avi");
 195   EXPECT_STREQ(ref.c_str(), var.c_str());
 196
 197   ref = "C:\\My Videos\\sub dir\\movie name.avi";
 198   var = URIUtils::SubstitutePath("https://myserver/some%20other%20path/sub%20dir/movie%20name.avi", true);
 199   EXPECT_STREQ(ref.c_str(), var.c_str());
 200
 201   ref = "D:\\Local Music\\MP3 Collection\\Phil Collins\\Some CD\\01 - Two Hearts.mp3";
 202   var = URIUtils::SubstitutePath("davs://otherserver/my%20music%20path/Phil%20Collins/Some%20CD/01%20-%20Two%20Hearts.mp3");
 203   EXPECT_STREQ(ref.c_str(), var.c_str());
 204
 205   ref = "davs://otherserver/my%20music%20path/Phil%20Collins/Some%20CD/01%20-%20Two%20Hearts.mp3";
 206   var = URIUtils::SubstitutePath("D:\\Local Music\\MP3 Collection\\Phil Collins\\Some CD\\01 - Two Hearts.mp3", true);
 207   EXPECT_STREQ(ref.c_str(), var.c_str());
 208
 209   ref = "/some/other/path2/to/movie.avi";
 210   var = URIUtils::SubstitutePath("/this/path1/to/movie.avi");
 211   EXPECT_STREQ(ref.c_str(), var.c_str());
 212
 213   ref = "/this/path1/to/movie.avi";
 214   var = URIUtils::SubstitutePath("/some/other/path2/to/movie.avi", true);
 215   EXPECT_STREQ(ref.c_str(), var.c_str());
 216
 217   ref = "/no/translation path/";
 218   var = URIUtils::SubstitutePath(ref);
 219   EXPECT_STREQ(ref.c_str(), var.c_str());
 220
 221   ref = "/no/translation path/";
 222   var = URIUtils::SubstitutePath(ref, true);
 223   EXPECT_STREQ(ref.c_str(), var.c_str());
 224
 225   ref = "c:\\no\\translation path";
 226   var = URIUtils::SubstitutePath(ref);
 227   EXPECT_STREQ(ref.c_str(), var.c_str());
 228
 229   ref = "c:\\no\\translation path";
 230   var = URIUtils::SubstitutePath(ref, true);
 231   EXPECT_STREQ(ref.c_str(), var.c_str());
 232 }
 233
 234 TEST_F(TestURIUtils, IsAddonsPath)
 235 {
 236   EXPECT_TRUE(URIUtils::IsAddonsPath("addons://path/to/addons"));
 237 }
 238
 239 TEST_F(TestURIUtils, IsSourcesPath)
 240 {
 241   EXPECT_TRUE(URIUtils::IsSourcesPath("sources://path/to/sources"));
 242 }
 243
 244 TEST_F(TestURIUtils, IsCDDA)
 245 {
 246   EXPECT_TRUE(URIUtils::IsCDDA("cdda://path/to/cdda"));
 247 }
 248
 249 TEST_F(TestURIUtils, IsDAAP)
 250 {
 251   EXPECT_TRUE(URIUtils::IsDAAP("daap://path/to/daap"));
 252 }
 253
 254 TEST_F(TestURIUtils, IsDOSPath)
 255 {
 256   EXPECT_TRUE(URIUtils::IsDOSPath("C://path/to/dosfile"));
 257 }
 258
 259 TEST_F(TestURIUtils, IsDVD)
 260 {
 261   EXPECT_TRUE(URIUtils::IsDVD("dvd://path/in/video_ts.ifo"));
 262 #if defined(TARGET_WINDOWS)
 263   EXPECT_TRUE(URIUtils::IsDVD("dvd://path/in/file"));
 264 #else
 265   EXPECT_TRUE(URIUtils::IsDVD("iso9660://path/in/video_ts.ifo"));
 266   EXPECT_TRUE(URIUtils::IsDVD("udf://path/in/video_ts.ifo"));
 267   EXPECT_TRUE(URIUtils::IsDVD("dvd://1"));
 268 #endif
 269 }
 270
 271 TEST_F(TestURIUtils, IsFTP)
 272 {
 273   EXPECT_TRUE(URIUtils::IsFTP("ftp://path/in/ftp"));
 274 }
 275
 276 TEST_F(TestURIUtils, IsHD)
 277 {
 278   EXPECT_TRUE(URIUtils::IsHD("/path/to/file"));
 279   EXPECT_TRUE(URIUtils::IsHD("file:///path/to/file"));
 280   EXPECT_TRUE(URIUtils::IsHD("special://path/to/file"));
 281   EXPECT_TRUE(URIUtils::IsHD("stack://path/to/file"));
 282   EXPECT_TRUE(URIUtils::IsHD("zip://path/to/file"));
 283   EXPECT_TRUE(URIUtils::IsHD("rar://path/to/file"));
 284 }
 285
 286 TEST_F(TestURIUtils, IsHDHomeRun)
 287 {
 288   EXPECT_TRUE(URIUtils::IsHDHomeRun("hdhomerun://path/to/file"));
 289 }
 290
 291 TEST_F(TestURIUtils, IsSlingbox)
 292 {
 293   EXPECT_TRUE(URIUtils::IsSlingbox("sling://path/to/file"));
 294 }
 295
 296 TEST_F(TestURIUtils, IsHTSP)
 297 {
 298   EXPECT_TRUE(URIUtils::IsHTSP("htsp://path/to/file"));
 299 }
 300
 301 TEST_F(TestURIUtils, IsInArchive)
 302 {
 303   EXPECT_TRUE(URIUtils::IsInArchive("zip://path/to/file"));
 304   EXPECT_TRUE(URIUtils::IsInArchive("rar://path/to/file"));
 305 }
 306
 307 TEST_F(TestURIUtils, IsInRAR)
 308 {
 309   EXPECT_TRUE(URIUtils::IsInRAR("rar://path/to/file"));
 310 }
 311
 312 TEST_F(TestURIUtils, IsInternetStream)
 313 {
 314   CURL url1("http://path/to/file");
 315   CURL url2("https://path/to/file");
 316   EXPECT_TRUE(URIUtils::IsInternetStream(url1));
 317   EXPECT_TRUE(URIUtils::IsInternetStream(url2));
 318 }
 319
 320 TEST_F(TestURIUtils, IsInZIP)
 321 {
 322   EXPECT_TRUE(URIUtils::IsInZIP("zip://path/to/file"));
 323 }
 324
 325 TEST_F(TestURIUtils, IsISO9660)
 326 {
 327   EXPECT_TRUE(URIUtils::IsISO9660("iso9660://path/to/file"));
 328 }
 329
 330 TEST_F(TestURIUtils, IsLiveTV)
 331 {
 332   EXPECT_TRUE(URIUtils::IsLiveTV("tuxbox://path/to/file"));
 333   EXPECT_TRUE(URIUtils::IsLiveTV("vtp://path/to/file"));
 334   EXPECT_TRUE(URIUtils::IsLiveTV("hdhomerun://path/to/file"));
 335   EXPECT_TRUE(URIUtils::IsLiveTV("sling://path/to/file"));
 336   EXPECT_TRUE(URIUtils::IsLiveTV("htsp://path/to/file"));
 337   EXPECT_TRUE(URIUtils::IsLiveTV("sap://path/to/file"));
 338   EXPECT_TRUE(URIUtils::IsLiveTV("myth://path/channels/"));
 339 }
 340
 341 TEST_F(TestURIUtils, IsMultiPath)
 342 {
 343   EXPECT_TRUE(URIUtils::IsMultiPath("multipath://path/to/file"));
 344 }
 345
 346 TEST_F(TestURIUtils, IsMusicDb)
 347 {
 348   EXPECT_TRUE(URIUtils::IsMusicDb("musicdb://path/to/file"));
 349 }
 350
 351 TEST_F(TestURIUtils, IsMythTV)
 352 {
 353   EXPECT_TRUE(URIUtils::IsMythTV("myth://path/to/file"));
 354 }
 355
 356 TEST_F(TestURIUtils, IsNfs)
 357 {
 358   EXPECT_TRUE(URIUtils::IsNfs("nfs://path/to/file"));
 359   EXPECT_TRUE(URIUtils::IsNfs("stack://nfs://path/to/file"));
 360 }
 361
 362 TEST_F(TestURIUtils, IsAfp)
 363 {
 364   EXPECT_TRUE(URIUtils::IsAfp("afp://path/to/file"));
 365   EXPECT_TRUE(URIUtils::IsAfp("stack://afp://path/to/file"));
 366 }
 367
 368 TEST_F(TestURIUtils, IsOnDVD)
 369 {
 370   EXPECT_TRUE(URIUtils::IsOnDVD("dvd://path/to/file"));
 371   EXPECT_TRUE(URIUtils::IsOnDVD("udf://path/to/file"));
 372   EXPECT_TRUE(URIUtils::IsOnDVD("iso9660://path/to/file"));
 373   EXPECT_TRUE(URIUtils::IsOnDVD("cdda://path/to/file"));
 374 }
 375
 376 TEST_F(TestURIUtils, IsOnLAN)
 377 {
 378   EXPECT_TRUE(URIUtils::IsOnLAN("multipath://daap://path/to/file"));
 379   EXPECT_TRUE(URIUtils::IsOnLAN("stack://daap://path/to/file"));
 380   EXPECT_TRUE(URIUtils::IsOnLAN("daap://path/to/file"));
 381   EXPECT_FALSE(URIUtils::IsOnLAN("plugin://path/to/file"));
 382   EXPECT_TRUE(URIUtils::IsOnLAN("tuxbox://path/to/file"));
 383   EXPECT_TRUE(URIUtils::IsOnLAN("upnp://path/to/file"));
 384 }
 385
 386 TEST_F(TestURIUtils, IsPlugin)
 387 {
 388   EXPECT_TRUE(URIUtils::IsPlugin("plugin://path/to/file"));
 389 }
 390
 391 TEST_F(TestURIUtils, IsScript)
 392 {
 393   EXPECT_TRUE(URIUtils::IsScript("script://path/to/file"));
 394 }
 395
 396 TEST_F(TestURIUtils, IsRAR)
 397 {
 398   EXPECT_TRUE(URIUtils::IsRAR("/path/to/rarfile.rar"));
 399   EXPECT_TRUE(URIUtils::IsRAR("/path/to/rarfile.cbr"));
 400   EXPECT_FALSE(URIUtils::IsRAR("/path/to/file"));
 401   EXPECT_FALSE(URIUtils::IsRAR("rar://path/to/file"));
 402 }
 403
 404 TEST_F(TestURIUtils, IsRemote)
 405 {
 406   EXPECT_TRUE(URIUtils::IsRemote("http://path/to/file"));
 407   EXPECT_TRUE(URIUtils::IsRemote("https://path/to/file"));
 408 }
 409
 410 TEST_F(TestURIUtils, IsSmb)
 411 {
 412   EXPECT_TRUE(URIUtils::IsSmb("smb://path/to/file"));
 413   EXPECT_TRUE(URIUtils::IsSmb("stack://smb://path/to/file"));
 414 }
 415
 416 TEST_F(TestURIUtils, IsSpecial)
 417 {
 418   EXPECT_TRUE(URIUtils::IsSpecial("special://path/to/file"));
 419   EXPECT_TRUE(URIUtils::IsSpecial("stack://special://path/to/file"));
 420 }
 421
 422 TEST_F(TestURIUtils, IsStack)
 423 {
 424   EXPECT_TRUE(URIUtils::IsStack("stack://path/to/file"));
 425 }
 426
 427 TEST_F(TestURIUtils, IsTuxBox)
 428 {
 429   EXPECT_TRUE(URIUtils::IsTuxBox("tuxbox://path/to/file"));
 430 }
 431
 432 TEST_F(TestURIUtils, IsUPnP)
 433 {
 434   EXPECT_TRUE(URIUtils::IsUPnP("upnp://path/to/file"));
 435 }
 436
 437 TEST_F(TestURIUtils, IsURL)
 438 {
 439   EXPECT_TRUE(URIUtils::IsURL("someprotocol://path/to/file"));
 440   EXPECT_FALSE(URIUtils::IsURL("/path/to/file"));
 441 }
 442
 443 TEST_F(TestURIUtils, IsVideoDb)
 444 {
 445   EXPECT_TRUE(URIUtils::IsVideoDb("videodb://path/to/file"));
 446 }
 447
 448 TEST_F(TestURIUtils, IsVTP)
 449 {
 450   EXPECT_TRUE(URIUtils::IsVTP("vtp://path/to/file"));
 451 }
 452
 453 TEST_F(TestURIUtils, IsZIP)
 454 {
 455   EXPECT_TRUE(URIUtils::IsZIP("/path/to/zipfile.zip"));
 456   EXPECT_TRUE(URIUtils::IsZIP("/path/to/zipfile.cbz"));
 457   EXPECT_FALSE(URIUtils::IsZIP("/path/to/file"));
 458   EXPECT_FALSE(URIUtils::IsZIP("zip://path/to/file"));
 459 }
 460
 461 TEST_F(TestURIUtils, IsBluray)
 462 {
 463   EXPECT_TRUE(URIUtils::IsBluray("bluray://path/to/file"));
 464 }
 465
 466 TEST_F(TestURIUtils, AddSlashAtEnd)
 467 {
 468   CStdString ref, var;
 469
 470   ref = "bluray://path/to/file/";
 471   var = "bluray://path/to/file/";
 472   URIUtils::AddSlashAtEnd(var);
 473   EXPECT_STREQ(ref.c_str(), var.c_str());
 474 }
 475
 476 TEST_F(TestURIUtils, HasSlashAtEnd)
 477 {
 478   EXPECT_TRUE(URIUtils::HasSlashAtEnd("bluray://path/to/file/"));
 479   EXPECT_FALSE(URIUtils::HasSlashAtEnd("bluray://path/to/file"));
 480 }
 481
 482 TEST_F(TestURIUtils, RemoveSlashAtEnd)
 483 {
 484   CStdString ref, var;
 485
 486   ref = "bluray://path/to/file";
 487   var = "bluray://path/to/file/";
 488   URIUtils::RemoveSlashAtEnd(var);
 489   EXPECT_STREQ(ref.c_str(), var.c_str());
 490 }
 491
 492 TEST_F(TestURIUtils, CreateArchivePath)
 493 {
 494   CStdString ref, var;
 495
 496   ref = "file://%2fpath%2fto%2f/file";
 497   URIUtils::CreateArchivePath(var, "file", "/path/to/", "file");
 498   EXPECT_STREQ(ref.c_str(), var.c_str());
 499 }
 500
 501 TEST_F(TestURIUtils, AddFileToFolder)
 502 {
 503   CStdString ref = "/path/to/file";
 504   CStdString var = URIUtils::AddFileToFolder("/path/to", "file");
 505   EXPECT_STREQ(ref.c_str(), var.c_str());
 506 }
 507
 508 TEST_F(TestURIUtils, ProtocolHasParentInHostname)
 509 {
 510   EXPECT_TRUE(URIUtils::ProtocolHasParentInHostname("zip"));
 511   EXPECT_TRUE(URIUtils::ProtocolHasParentInHostname("rar"));
 512   EXPECT_TRUE(URIUtils::ProtocolHasParentInHostname("bluray"));
 513 }
 514
 515 TEST_F(TestURIUtils, ProtocolHasEncodedHostname)
 516 {
 517   EXPECT_TRUE(URIUtils::ProtocolHasEncodedHostname("zip"));
 518   EXPECT_TRUE(URIUtils::ProtocolHasEncodedHostname("rar"));
 519   EXPECT_TRUE(URIUtils::ProtocolHasEncodedHostname("bluray"));
 520   EXPECT_TRUE(URIUtils::ProtocolHasEncodedHostname("musicsearch"));
 521 }
 522
 523 TEST_F(TestURIUtils, ProtocolHasEncodedFilename)
 524 {
 525   EXPECT_TRUE(URIUtils::ProtocolHasEncodedFilename("shout"));
 526   EXPECT_TRUE(URIUtils::ProtocolHasEncodedFilename("daap"));
 527   EXPECT_TRUE(URIUtils::ProtocolHasEncodedFilename("dav"));
 528   EXPECT_TRUE(URIUtils::ProtocolHasEncodedFilename("tuxbox"));
 529   EXPECT_TRUE(URIUtils::ProtocolHasEncodedFilename("rss"));
 530   EXPECT_TRUE(URIUtils::ProtocolHasEncodedFilename("davs"));
 531 }
 532
 533 TEST_F(TestURIUtils, GetRealPath)
 534 {
 535   std::string ref;
 536
 537   ref = "/path/to/file/";
 538   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath(ref).c_str());
 539
 540   ref = "path/to/file";
 541   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath("../path/to/file").c_str());
 542   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath("./path/to/file").c_str());
 543
 544   ref = "/path/to/file";
 545   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath(ref).c_str());
 546   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath("/path/to/./file").c_str());
 547   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath("/./path/to/./file").c_str());
 548   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath("/path/to/some/../file").c_str());
 549   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath("/../path/to/some/../file").c_str());
 550
 551   ref = "/path/to";
 552   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath("/path/to/some/../file/..").c_str());
 553
 554 #ifdef TARGET_WINDOWS
 555   ref = "\\\\path\\to\\file\\";
 556   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath(ref).c_str());
 557
 558   ref = "path\\to\\file";
 559   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath("..\\path\\to\\file").c_str());
 560   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath(".\\path\\to\\file").c_str());
 561
 562   ref = "\\\\path\\to\\file";
 563   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath(ref).c_str());
 564   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath("\\\\path\\to\\.\\file").c_str());
 565   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath("\\\\.\\path/to\\.\\file").c_str());
 566   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath("\\\\path\\to\\some\\..\\file").c_str());
 567   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath("\\\\..\\path\\to\\some\\..\\file").c_str());
 568
 569   ref = "\\\\path\\to";
 570   EXPECT_STREQ(ref.c_str(), URIUtils::GetRealPath("\\\\path\\to\\some\\..\\file\\..").c_str());
 571 #endif
 572
 573   // test rar/zip paths
 574   ref = "rar://%2fpath%2fto%2frar/subpath/to/file";
 575   EXPECT_STRCASEEQ(ref.c_str(), URIUtils::GetRealPath(ref).c_str());
 576
 577   // test rar/zip paths
 578   ref = "rar://%2fpath%2fto%2frar/subpath/to/file";
 579   EXPECT_STRCASEEQ(ref.c_str(), URIUtils::GetRealPath("rar://%2fpath%2fto%2frar/../subpath/to/file").c_str());
 580   EXPECT_STRCASEEQ(ref.c_str(), URIUtils::GetRealPath("rar://%2fpath%2fto%2frar/./subpath/to/file").c_str());
 581   EXPECT_STRCASEEQ(ref.c_str(), URIUtils::GetRealPath("rar://%2fpath%2fto%2frar/subpath/to/./file").c_str());
 582   EXPECT_STRCASEEQ(ref.c_str(), URIUtils::GetRealPath("rar://%2fpath%2fto%2frar/subpath/to/some/../file").c_str());
 583
 584   EXPECT_STRCASEEQ(ref.c_str(), URIUtils::GetRealPath("rar://%2fpath%2fto%2f.%2frar/subpath/to/file").c_str());
 585   EXPECT_STRCASEEQ(ref.c_str(), URIUtils::GetRealPath("rar://%2fpath%2fto%2fsome%2f..%2frar/subpath/to/file").c_str());
 586
 587   // test rar/zip path in rar/zip path
 588   ref ="zip://rar%3A%2F%2F%252Fpath%252Fto%252Frar%2Fpath%2Fto%2Fzip/subpath/to/file";
 589   EXPECT_STRCASEEQ(ref.c_str(), URIUtils::GetRealPath("zip://rar%3A%2F%2F%252Fpath%252Fto%252Fsome%252F..%252Frar%2Fpath%2Fto%2Fsome%2F..%2Fzip/subpath/to/some/../file").c_str());
 590 }
 591
 592 TEST_F(TestURIUtils, UpdateUrlEncoding)
 593 {
 594   std::string oldUrl = "stack://rar://%2fpath%2fto%2farchive%2fsome%2darchive%2dfile%2eCD1%2erar/video.avi , rar://%2fpath%2fto%2farchive%2fsome%2darchive%2dfile%2eCD2%2erar/video.avi";
 595   std::string newUrl = "stack://rar://%2fpath%2fto%2farchive%2fsome-archive-file.CD1.rar/video.avi , rar://%2fpath%2fto%2farchive%2fsome-archive-file.CD2.rar/video.avi";
 596
 597   EXPECT_TRUE(URIUtils::UpdateUrlEncoding(oldUrl));
 598   EXPECT_STRCASEEQ(newUrl.c_str(), oldUrl.c_str());
 599
 600   oldUrl = "rar://%2fpath%2fto%2farchive%2fsome%2darchive%2efile%2erar/video.avi";
 601   newUrl = "rar://%2fpath%2fto%2farchive%2fsome-archive.file.rar/video.avi";
 602
 603   EXPECT_TRUE(URIUtils::UpdateUrlEncoding(oldUrl));
 604   EXPECT_STRCASEEQ(newUrl.c_str(), oldUrl.c_str());
 605
 606   oldUrl = "/path/to/some/long%2dnamed%2efile";
 607   newUrl = "/path/to/some/long%2dnamed%2efile";
 608
 609   EXPECT_FALSE(URIUtils::UpdateUrlEncoding(oldUrl));
 610   EXPECT_STRCASEEQ(newUrl.c_str(), oldUrl.c_str());
 611
 612   oldUrl = "/path/to/some/long-named.file";
 613   newUrl = "/path/to/some/long-named.file";
 614
 615   EXPECT_FALSE(URIUtils::UpdateUrlEncoding(oldUrl));
 616   EXPECT_STRCASEEQ(newUrl.c_str(), oldUrl.c_str());
 617 }