xpcom/tests/nsIFileTest.cpp

   1 #include "nsILocalFile.h"
   2 #include "nsStringGlue.h"
   3
   4 #include <stdio.h>
   5 #include "nsXPCOM.h"
   6 #include "nsIComponentManager.h"
   7 #include "nsIComponentRegistrar.h"
   8 #include "nsIServiceManager.h"
   9 #include "nsIMemory.h"
  10
  11 #include "nsComponentManagerUtils.h"
  12 #include "nsCOMPtr.h"
  13
  14 void Passed();
  15 void Failed(const char* explanation = nsnull);
  16 void Inspect();
  17 void Banner(const char* bannerString);
  18
  19 void VerifyResult(nsresult rv)
  20 {
  21     if (NS_FAILED(rv))
  22     {
  23         Failed("rv failed");
  24         printf("rv = %d\n", rv);
  25     }
  26 }
  27 //----------------------------------------------------------------------------
  28 void Banner(const char* bannerString)
  29 //----------------------------------------------------------------------------
  30 {
  31     printf("---------------------------\n");
  32     printf("%s\n", bannerString);
  33     printf("---------------------------\n");
  34 }
  35
  36 //----------------------------------------------------------------------------
  37 void Passed()
  38 //----------------------------------------------------------------------------
  39 {
  40     printf("Test passed.");
  41 }
  42
  43 //----------------------------------------------------------------------------
  44 void Failed(const char* explanation)
  45 //----------------------------------------------------------------------------
  46 {
  47     printf("ERROR : Test failed.\n");
  48     printf("REASON: %s.\n", explanation);
  49 }
  50
  51 //----------------------------------------------------------------------------
  52 void Inspect()
  53 //----------------------------------------------------------------------------
  54 {
  55     printf("^^^^^^^^^^ PLEASE INSPECT OUTPUT FOR ERRORS\n");
  56 }
  57
  58 void GetPaths(nsILocalFile* file)
  59 {
  60     nsresult rv;
  61     nsCAutoString pathName;
  62
  63     printf("Getting Path\n");
  64
  65     rv = file->GetNativePath(pathName);
  66     VerifyResult(rv);
  67
  68     printf("filepath: %s\n", pathName.get());
  69 }
  70
  71 void InitTest(const char* creationPath, const char* appendPath)
  72 {
  73     nsILocalFile* file = nsnull;
  74     nsresult rv = CallCreateInstance(NS_LOCAL_FILE_CONTRACTID, &file);
  75
  76     if (NS_FAILED(rv) || (!file))
  77     {
  78         printf("create nsILocalFile failed\n");
  79         return;
  80     }
  81
  82     nsCAutoString leafName;
  83
  84     Banner("InitWithPath");
  85     printf("creationPath == %s\nappendPath == %s\n", creationPath, appendPath);
  86
  87     rv = file->InitWithNativePath(nsDependentCString(creationPath));
  88     VerifyResult(rv);
  89
  90     printf("Getting Filename\n");
  91     rv = file->GetNativeLeafName(leafName);
  92     printf(" %s\n", leafName.get());
  93     VerifyResult(rv);
  94
  95     printf("Appending %s \n", appendPath);
  96     rv = file->AppendNative(nsDependentCString(appendPath));
  97     VerifyResult(rv);
  98
  99     printf("Getting Filename\n");
 100     rv = file->GetNativeLeafName(leafName);
 101     printf(" %s\n", leafName.get());
 102     VerifyResult(rv);
 103
 104     GetPaths(file);
 105
 106
 107     printf("Check For Existence\n");
 108
 109     PRBool exists;
 110     file->Exists(&exists);
 111
 112     if (exists)
 113         printf("Yup!\n");
 114     else
 115         printf("no.\n");
 116 }
 117
 118
 119 void CreationTest(const char* creationPath, const char* appendPath,
 120                   PRInt32 whatToCreate, PRInt32 perm)
 121 {
 122     nsresult rv;
 123     nsCOMPtr<nsILocalFile> file =
 124         do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
 125
 126     if (NS_FAILED(rv) || (!file))
 127     {
 128         printf("create nsILocalFile failed\n");
 129         return;
 130     }
 131
 132     Banner("Creation Test");
 133     printf("creationPath == %s\nappendPath == %s\n", creationPath, appendPath);
 134
 135     rv = file->InitWithNativePath(nsDependentCString(creationPath));
 136     VerifyResult(rv);
 137
 138     printf("Appending %s\n", appendPath);
 139     rv = file->AppendRelativeNativePath(nsDependentCString(appendPath));
 140     VerifyResult(rv);
 141
 142     printf("Check For Existence\n");
 143
 144     PRBool exists;
 145     file->Exists(&exists);
 146
 147     if (exists)
 148         printf("Yup!\n");
 149     else
 150         printf("no.\n");
 151
 152
 153     rv = file->Create(whatToCreate, perm);
 154     VerifyResult(rv);
 155
 156     rv = file->Exists(&exists);
 157     VerifyResult(rv);
 158
 159
 160     if (!exists)
 161     {
 162         Failed("Did not create file system object!");
 163         return;
 164     }
 165
 166 }
 167
 168 void CreateUniqueTest(const char* creationPath, const char* appendPath,
 169                  PRInt32 whatToCreate, PRInt32 perm)
 170 {
 171     nsresult rv;
 172     nsCOMPtr<nsILocalFile> file =
 173         do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
 174
 175     if (NS_FAILED(rv) || (!file))
 176     {
 177         printf("create nsILocalFile failed\n");
 178         return;
 179     }
 180
 181     Banner("Creation Test");
 182     printf("creationPath == %s\nappendPath == %s\n", creationPath, appendPath);
 183
 184     rv = file->InitWithNativePath(nsDependentCString(creationPath));
 185     VerifyResult(rv);
 186
 187     printf("Appending %s\n", appendPath);
 188     rv = file->AppendNative(nsDependentCString(appendPath));
 189     VerifyResult(rv);
 190
 191     printf("Check For Existence\n");
 192
 193     PRBool exists;
 194     file->Exists(&exists);
 195
 196     if (exists)
 197         printf("Yup!\n");
 198     else
 199         printf("no.\n");
 200
 201
 202     rv = file->CreateUnique(whatToCreate, perm);
 203     VerifyResult(rv);
 204
 205     rv = file->Exists(&exists);
 206     VerifyResult(rv);
 207
 208
 209     if (!exists)
 210     {
 211         Failed("Did not create file system object!");
 212         return;
 213     }
 214
 215 }
 216
 217
 218 void
 219 CopyTest(const char *testFile, const char *targetDir)
 220 {
 221   printf("start copy test\n");
 222
 223   nsresult rv;
 224   nsCOMPtr<nsILocalFile> file =
 225       do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
 226
 227   if (NS_FAILED(rv) || (!file))
 228   {
 229     printf("create nsILocalFile failed\n");
 230     return;
 231   }
 232
 233   rv = file->InitWithNativePath(nsDependentCString(testFile));
 234   VerifyResult(rv);
 235
 236   nsCOMPtr<nsILocalFile> dir =
 237       do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
 238
 239   if (NS_FAILED(rv) || (!dir))
 240   {
 241     printf("create nsILocalFile failed\n");
 242     return;
 243   }
 244
 245   rv = dir->InitWithNativePath(nsDependentCString(targetDir));
 246   VerifyResult(rv);
 247
 248   rv = file->CopyTo(dir, EmptyString());
 249   VerifyResult(rv);
 250
 251   printf("end copy test\n");
 252 }
 253
 254 void
 255 DeletionTest(const char* creationPath, const char* appendPath, PRBool recursive)
 256 {
 257     nsresult rv;
 258     nsCOMPtr<nsILocalFile> file =
 259             do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
 260
 261     if (NS_FAILED(rv) || (!file))
 262     {
 263         printf("create nsILocalFile failed\n");
 264         return;
 265     }
 266
 267     Banner("Deletion Test");
 268     printf("creationPath == %s\nappendPath == %s\n", creationPath, appendPath);
 269
 270     rv = file->InitWithNativePath(nsDependentCString(creationPath));
 271     VerifyResult(rv);
 272
 273     printf("Appending %s\n", appendPath);
 274     rv = file->AppendNative(nsDependentCString(appendPath));
 275     VerifyResult(rv);
 276
 277     printf("Check For Existance\n");
 278
 279     PRBool exists;
 280     file->Exists(&exists);
 281
 282     if (exists)
 283         printf("Yup!\n");
 284     else
 285         printf("no.\n");
 286
 287     rv = file->Remove(recursive);
 288     VerifyResult(rv);
 289
 290     rv = file->Exists(&exists);
 291     VerifyResult(rv);
 292
 293     if (exists)
 294     {
 295         Failed("Did not create delete system object!");
 296         return;
 297     }
 298
 299 }
 300
 301 void
 302 MoveTest(const char *testFile, const char *targetDir)
 303 {
 304   Banner("Move Test");
 305
 306   printf("start move test\n");
 307
 308   nsresult rv;
 309   nsCOMPtr<nsILocalFile> file(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID));
 310
 311   if (!file)
 312   {
 313     printf("create nsILocalFile failed\n");
 314     return;
 315   }
 316
 317   rv = file->InitWithNativePath(nsDependentCString(testFile));
 318   VerifyResult(rv);
 319
 320   nsCOMPtr<nsILocalFile> dir(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID));
 321
 322   if (!dir)
 323   {
 324     printf("create nsILocalFile failed\n");
 325     return;
 326   }
 327
 328   rv = dir->InitWithNativePath(nsDependentCString(targetDir));
 329   VerifyResult(rv);
 330
 331   rv = file->MoveToNative(dir, NS_LITERAL_CSTRING("newtemp"));
 332   VerifyResult(rv);
 333   if (NS_FAILED(rv))
 334   {
 335     printf("MoveToNative() test Failed.\n");
 336   }
 337   printf("end move test\n");
 338 }
 339
 340 // move up the number of directories in moveUpCount, then append "foo/bar"
 341 void
 342 NormalizeTest(const char *testPath, int moveUpCount,
 343               const char *expected)
 344 {
 345   Banner("Normalize Test");
 346
 347   nsresult rv;
 348   nsCOMPtr<nsILocalFile> file(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID));
 349
 350   if (!file)
 351   {
 352     printf("create nsILocalFile failed\n");
 353     return;
 354   }
 355
 356   rv = file->InitWithNativePath(nsDependentCString(testPath));
 357   VerifyResult(rv);
 358
 359   nsCOMPtr<nsIFile> parent;
 360   nsAutoString path;
 361   for (int i=0; i < moveUpCount; i++)
 362   {
 363     rv = file->GetParent(getter_AddRefs(parent));
 364     VerifyResult(rv);
 365     rv = parent->GetPath(path);
 366     VerifyResult(rv);
 367     rv = file->InitWithPath(path);
 368     VerifyResult(rv);
 369   }
 370
 371   if (!parent) {
 372     printf("Getting parent failed!\n");
 373     return;
 374   }
 375
 376   rv = parent->Append(NS_LITERAL_STRING("foo"));
 377   VerifyResult(rv);
 378   rv = parent->Append(NS_LITERAL_STRING("bar"));
 379   VerifyResult(rv);
 380
 381   rv = parent->Normalize();
 382   VerifyResult(rv);
 383
 384   nsCAutoString newPath;
 385   rv = parent->GetNativePath(newPath);
 386   VerifyResult(rv);
 387
 388   nsCOMPtr<nsILocalFile>
 389     expectedFile(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID));
 390
 391   if (!expectedFile)
 392   {
 393     printf("create nsILocalFile failed\n");
 394     return;
 395   }
 396   rv = expectedFile->InitWithNativePath(nsDependentCString(expected));
 397   VerifyResult(rv);
 398
 399   rv = expectedFile->Normalize();
 400   VerifyResult(rv);
 401
 402   nsCAutoString expectedPath;
 403   rv = expectedFile->GetNativePath(expectedPath);
 404   VerifyResult(rv);
 405
 406   if (!newPath.Equals(expectedPath)) {
 407     printf("ERROR: Normalize() test Failed!\n");
 408     printf("     Got: %s\n", newPath.get());
 409     printf("Expected: %s\n", expectedPath.get());
 410   }
 411
 412   printf("end normalize test.\n");
 413 }
 414
 415 int main(void)
 416 {
 417     nsCOMPtr<nsIServiceManager> servMan;
 418     NS_InitXPCOM2(getter_AddRefs(servMan), nsnull, nsnull);
 419     nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface(servMan);
 420     NS_ASSERTION(registrar, "Null nsIComponentRegistrar");
 421     registrar->AutoRegister(nsnull);
 422
 423 #if defined(XP_WIN) || defined(XP_OS2)
 424     InitTest("c:\\temp\\", "sub1/sub2/"); // expect failure
 425     InitTest("d:\\temp\\", "sub1\\sub2\\"); // expect failure
 426
 427     CreationTest("c:\\temp\\", "file.txt", nsIFile::NORMAL_FILE_TYPE, 0644);
 428     DeletionTest("c:\\temp\\", "file.txt", PR_FALSE);
 429
 430     MoveTest("c:\\newtemp\\", "d:");
 431
 432     CreationTest("c:\\temp\\", "mumble\\a\\b\\c\\d\\e\\f\\g\\h\\i\\j\\k\\", nsIFile::DIRECTORY_TYPE, 0644);
 433     DeletionTest("c:\\temp\\", "mumble", PR_TRUE);
 434
 435     CreateUniqueTest("c:\\temp\\", "foo", nsIFile::NORMAL_FILE_TYPE, 0644);
 436     CreateUniqueTest("c:\\temp\\", "foo", nsIFile::NORMAL_FILE_TYPE, 0644);
 437     CreateUniqueTest("c:\\temp\\", "bar.xx", nsIFile::DIRECTORY_TYPE, 0644);
 438     CreateUniqueTest("c:\\temp\\", "bar.xx", nsIFile::DIRECTORY_TYPE, 0644);
 439     DeletionTest("c:\\temp\\", "foo", PR_TRUE);
 440     DeletionTest("c:\\temp\\", "foo-1", PR_TRUE);
 441     DeletionTest("c:\\temp\\", "bar.xx", PR_TRUE);
 442     DeletionTest("c:\\temp\\", "bar-1.xx", PR_TRUE);
 443
 444 #else
 445 #ifdef XP_UNIX
 446     InitTest("/tmp/", "sub1/sub2/"); // expect failure
 447
 448     CreationTest("/tmp", "file.txt", nsIFile::NORMAL_FILE_TYPE, 0644);
 449     DeletionTest("/tmp/", "file.txt", PR_FALSE);
 450
 451     CreationTest("/tmp", "mumble/a/b/c/d/e/f/g/h/i/j/k/", nsIFile::DIRECTORY_TYPE, 0644);
 452     DeletionTest("/tmp", "mumble", PR_TRUE);
 453
 454     CreationTest("/tmp", "file", nsIFile::NORMAL_FILE_TYPE, 0644);
 455     CopyTest("/tmp/file", "/tmp/newDir");
 456     MoveTest("/tmp/file", "/tmp/newDir/anotherNewDir");
 457     DeletionTest("/tmp", "newDir", PR_TRUE);
 458
 459     CreationTest("/tmp", "qux/quux", nsIFile::NORMAL_FILE_TYPE, 0644);
 460     CreationTest("/tmp", "foo/bar", nsIFile::NORMAL_FILE_TYPE, 0644);
 461     NormalizeTest("/tmp/qux/quux/..", 1, "/tmp/foo/bar");
 462     DeletionTest("/tmp", "qux", PR_TRUE);
 463     DeletionTest("/tmp", "foo", PR_TRUE);
 464
 465 #endif /* XP_UNIX */
 466 #endif /* XP_WIN || XP_OS2 */
 467     return 0;
 468 }