mcs/class/corlib/Test/System.IO/FileInfoTest.cs

   1 // FileInfoTest.cs - NUnit Test Cases for System.IO.FileInfo class
   2 //
   3 // Ville Palo (vi64pa@koti.soon.fi)
   4 //
   5 // (C) 2003 Ville Palo
   6 //
   7
   8 using System;
   9 using System.IO;
  10 using System.Runtime.Serialization;
  11 using System.Runtime.Serialization.Formatters.Binary;
  12
  13 using NUnit.Framework;
  14
  15 namespace MonoTests.System.IO
  16 {
  17         [TestFixture]
  18         public class FileInfoTest
  19         {
  20                 string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");
  21                 static readonly char DSC = Path.DirectorySeparatorChar;
  22
  23                 [SetUp]
  24                 public void SetUp ()
  25                 {
  26                         DeleteDirectory (TempFolder);
  27                         Directory.CreateDirectory (TempFolder);
  28                 }
  29
  30                 [TearDown]
  31                 public void TearDown ()
  32                 {
  33                         DeleteDirectory (TempFolder);
  34                 }
  35
  36                 [Test] // ctor (String)
  37                 public void Constructor1 ()
  38                 {
  39                         string path = TempFolder + DSC + "FIT.Ctr.Test";
  40                         DeleteFile (path);
  41
  42                         FileInfo info = new FileInfo (path);
  43                         Assert.IsTrue (info.DirectoryName.EndsWith (".Tests"), "#1");
  44                         Assert.IsFalse (info.Exists, "#2");
  45                         Assert.AreEqual (".Test", info.Extension, "#3");
  46                         Assert.AreEqual ("FIT.Ctr.Test", info.Name, "#4");
  47                 }
  48
  49                 [Test] // ctor (String)
  50                 public void Constructor1_FileName_Null ()
  51                 {
  52                         try {
  53                                 new FileInfo (null);
  54                                 Assert.Fail ("#1");
  55                         } catch (ArgumentNullException ex) {
  56                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
  57                                 Assert.IsNull (ex.InnerException, "#3");
  58                                 Assert.IsNotNull (ex.Message, "#4");
  59                                 Assert.AreEqual ("fileName", ex.ParamName, "#5");
  60                         }
  61                 }
  62
  63                 [Test] // ctor (String)
  64                 public void Constructor1_FileName_Empty ()
  65                 {
  66                         try {
  67                                 new FileInfo (string.Empty);
  68                                 Assert.Fail ("#1");
  69                         } catch (ArgumentException ex) {
  70                                 // Empty file name is not legal
  71                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
  72                                 Assert.IsNull (ex.InnerException, "#3");
  73                                 Assert.IsNotNull (ex.Message, "#4");
  74                                 Assert.IsNull (ex.ParamName, "#5");
  75                         }
  76                 }
  77
  78                 [Test] // ctor (String)
  79                 public void Constructor1_FileName_InvalidPathChars ()
  80                 {
  81                         string path = string.Empty;
  82                         foreach (char c in Path.InvalidPathChars)
  83                                 path += c;
  84                         try {
  85                                 new FileInfo (path);
  86                         } catch (ArgumentException ex) {
  87                                 // The path contains illegal characters
  88                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
  89                                 Assert.IsNull (ex.InnerException, "#3");
  90                                 Assert.IsNotNull (ex.Message, "#4");
  91                                 Assert.IsNull (ex.ParamName, "#5");
  92                         }
  93                 }
  94
  95                 [Test] // ctor (String)
  96                 public void Constructor1_FileName_Whitespace ()
  97                 {
  98                         try {
  99                                 new FileInfo ("      ");
 100                                 Assert.Fail ("#1");
 101                         } catch (ArgumentException ex) {
 102                                 // The path is not of a legal form
 103                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 104                                 Assert.IsNull (ex.InnerException, "#3");
 105                                 Assert.IsNotNull (ex.Message, "#4");
 106                                 Assert.IsNull (ex.ParamName, "#5");
 107                         }
 108                 }
 109
 110                 [Test]
 111                 public void DirectoryTest ()
 112                 {
 113                         string path = TempFolder + DSC + "FIT.Directory.Test";
 114                         DeleteFile (path);
 115
 116                         FileInfo info = new FileInfo (path);
 117                         DirectoryInfo dir = info.Directory;
 118                         Assert.AreEqual ("MonoTests.System.IO.Tests", dir.Name);
 119                 }
 120
 121                 [Test]
 122                 public void Exists ()
 123                 {
 124                         string path = TempFolder + DSC + "FIT.Exists.Test";
 125                         DeleteFile (path);
 126
 127                         try {
 128                                 FileInfo info = new FileInfo (path);
 129                                 Assert.IsFalse (info.Exists, "#1");
 130
 131                                 File.Create (path).Close ();
 132                                 Assert.IsFalse (info.Exists, "#2");
 133                                 info = new FileInfo (path);
 134                                 Assert.IsTrue (info.Exists, "#3");
 135                                 info = new FileInfo (TempFolder);
 136                                 Assert.IsFalse (info.Exists, "#4");
 137                         } finally {
 138                                 DeleteFile (path);
 139                         }
 140                 }
 141
 142 #if !MOBILE
 143                 [Test]
 144                 [Category ("NotWorking")]
 145                 public void IsReadOnly ()
 146                 {
 147                         string path = TempFolder + DSC + "FIT.IsReadOnly.Test";
 148                         DeleteFile (path);
 149
 150                         try {
 151                                 using (FileStream stream = File.Create (path)) {
 152                                         stream.WriteByte (12);
 153                                         stream.Close ();
 154                                 }
 155
 156                                 FileInfo info1 = new FileInfo (path);
 157                                 Assert.IsFalse (info1.IsReadOnly, "#1");
 158
 159                                 FileInfo info2 = new FileInfo (path);
 160                                 info2.IsReadOnly = true;
 161                                 Assert.IsFalse (info1.IsReadOnly, "#2");
 162                                 Assert.IsTrue (info2.IsReadOnly, "#3");
 163
 164                                 FileInfo info3 = new FileInfo (path);
 165                                 Assert.IsTrue (info3.IsReadOnly, "#4");
 166                                 info3.IsReadOnly = false;
 167                                 Assert.IsFalse (info1.IsReadOnly, "#4");
 168                                 Assert.IsTrue (info2.IsReadOnly, "#5");
 169                                 Assert.IsFalse (info3.IsReadOnly, "#6");
 170                         } finally {
 171                                 File.SetAttributes (path, FileAttributes.Normal);
 172                                 DeleteFile (path);
 173                         }
 174                 }
 175 #endif
 176
 177                 [Test]
 178                 public void Length ()
 179                 {
 180                         string path = TempFolder + DSC + "FIT.Length.Test";
 181                         DeleteFile (path);
 182
 183                         try {
 184                                 FileStream stream = File.Create (path);
 185                                 FileInfo info = new FileInfo (path);
 186                                 Assert.AreEqual (0, info.Length, "#1");
 187                                 stream.WriteByte (12);
 188                                 stream.Flush ();
 189                                 Assert.AreEqual (0, info.Length, "#2");
 190                                 info = new FileInfo (path);
 191                                 Assert.AreEqual (1, info.Length, "#3");
 192                                 stream.Close ();
 193                         } finally {
 194                                 DeleteFile (path);
 195                         }
 196                 }
 197
 198                 [Test]
 199                 public void Length_FileDoesNotExist ()
 200                 {
 201                         string path = TempFolder + DSC + "FIT.LengthException.Test";
 202                         DeleteFile (path);
 203                         FileInfo info = new FileInfo (path);
 204                         try {
 205                                 long l = info.Length;
 206                                 Assert.Fail ("#1:" + l);
 207                         } catch (FileNotFoundException ex) {
 208                                 Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#2");
 209                                 Assert.AreEqual (path, ex.FileName, "#3");
 210                                 Assert.IsNull (ex.InnerException, "#4");
 211                                 Assert.IsNotNull (ex.Message, "#5");
 212                         }
 213                 }
 214
 215                 [Test]
 216                 public void AppendText ()
 217                 {
 218                         string path = TempFolder + DSC + "FIT.AppendText.Test";
 219                         DeleteFile (path);
 220
 221                         try {
 222                                 FileInfo info = new FileInfo (path);
 223                                 Assert.IsFalse (info.Exists, "#1");
 224
 225                                 StreamWriter writer = info.AppendText ();
 226                                 info = new FileInfo (path);
 227                                 Assert.IsTrue (info.Exists, "#2");
 228
 229                                 writer.Write ("aaa");
 230                                 writer.Flush ();
 231                                 writer.Close ();
 232
 233                                 Assert.AreEqual (0, info.Length, "#3");
 234                                 info = new FileInfo (path);
 235                                 Assert.AreEqual (3, info.Length, "#4");
 236                         } finally {
 237                                 DeleteFile (path);
 238                         }
 239                 }
 240
 241                 [Test] // CopyTo (String)
 242                 public void CopyTo1 ()
 243                 {
 244                         string path1 = TempFolder + DSC + "FIT.CopyTo.Source.Test";
 245                         string path2 = TempFolder + DSC + "FIT.CopyTo.Dest.Test";
 246                         DeleteFile (path1);
 247                         DeleteFile (path2);
 248                         try {
 249                                 File.Create (path1).Close ();
 250
 251                                 FileInfo info = new FileInfo (path1);
 252                                 Assert.IsTrue (info.Exists, "#1");
 253
 254                                 FileInfo info2 = info.CopyTo (path2);
 255                                 info = new FileInfo (path1);
 256                                 Assert.IsTrue (info2.Exists, "#2");
 257                         } finally {
 258                                 DeleteFile (path1);
 259                                 DeleteFile (path2);
 260                         }
 261                 }
 262
 263                 [Test] // CopyTo (String)
 264                 public void CopyTo1_DestFileName_AlreadyExists ()
 265                 {
 266                         string path1 = TempFolder + DSC + "FIT.CopyToException.Source.Test";
 267                         string path2 = TempFolder + DSC + "FIT.CopyToException.Dest.Test";
 268
 269                         try {
 270                                 DeleteFile (path1);
 271                                 DeleteFile (path2);
 272                                 File.Create (path1).Close ();
 273                                 File.Create (path2).Close ();
 274                                 FileInfo info = new FileInfo (path1);
 275                                 try {
 276                                         info.CopyTo (path2);
 277                                         Assert.Fail ("#1");
 278                                 } catch (IOException ex) {
 279                                         // The file '...' already exists.
 280                                         Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");
 281                                         Assert.IsNull (ex.InnerException, "#3");
 282                                         Assert.IsNotNull (ex.Message, "#4");
 283                                         Assert.IsTrue (ex.Message.IndexOf (path2) != -1, "#5");
 284                                 }
 285                         } finally {
 286                                 DeleteFile (path1);
 287                                 DeleteFile (path2);
 288                         }
 289                 }
 290
 291                 [Test] // CopyTo (String)
 292                 public void CopyTo1_DestFileName_Null ()
 293                 {
 294                         string path = TempFolder + DSC + "FIT.CopyToArgumentNullException.Test";
 295                         DeleteFile (path);
 296                         try {
 297                                 File.Create (path).Close ();
 298                                 FileInfo info = new FileInfo (path);
 299                                 try {
 300                                         info.CopyTo (null);
 301                                         Assert.Fail ("#1");
 302                                 } catch (ArgumentNullException ex) {
 303                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 304                                         Assert.IsNull (ex.InnerException, "#3");
 305                                         Assert.IsNotNull (ex.Message, "#4");
 306                                         Assert.AreEqual ("destFileName", ex.ParamName, "#5");
 307                                 }
 308                         } finally {
 309                                 DeleteFile (path);
 310                         }
 311                 }
 312
 313                 [Test] // CopyTo (String)
 314                 public void CopyTo1_DestFileName_Empty ()
 315                 {
 316                         string path = TempFolder + DSC + "FIT.CopyToArgument1Exception.Test";
 317                         DeleteFile (path);
 318
 319                         try {
 320                                 File.Create (path).Close ();
 321                                 FileInfo info = new FileInfo (path);
 322                                 try {
 323                                         info.CopyTo (string.Empty);
 324                                         Assert.Fail ("#1");
 325                                 } catch (ArgumentException ex) {
 326                                         // Empty file name is not legal
 327                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 328                                         Assert.IsNull (ex.InnerException, "#3");
 329                                         Assert.IsNotNull (ex.Message, "#4");
 330                                         Assert.AreEqual ("destFileName", ex.ParamName, "#5");
 331                                 }
 332                         } finally {
 333                                 DeleteFile (path);
 334                         }
 335                 }
 336
 337                 [Test] // CopyTo (String)
 338                 public void CopyTo1_DestFileName_Whitespace ()
 339                 {
 340                         string path = TempFolder + DSC + "FIT.CopyToArgument2Exception.Test";
 341                         DeleteFile (path);
 342
 343                         try {
 344                                 File.Create (path).Close ();
 345                                 FileInfo info = new FileInfo (path);
 346                                 try {
 347                                         info.CopyTo ("    ");
 348                                         Assert.Fail ("#1");
 349                                 } catch (ArgumentException ex) {
 350                                         // The path is not of a legal form
 351                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 352                                         Assert.IsNull (ex.InnerException, "#3");
 353                                         Assert.IsNotNull (ex.Message, "#4");
 354                                         Assert.IsNull (ex.ParamName, "#5");
 355                                 }
 356                         } finally {
 357                                 DeleteFile (path);
 358                         }
 359                 }
 360
 361                 [Test] // CopyTo (String)
 362                 public void CopyTo1_DestFileName_InvalidPathChars ()
 363                 {
 364                         string path = TempFolder + DSC + "FIT.CopyToArgument4Exception.Test";
 365                         string path2 = string.Empty;
 366                         DeleteFile (path);
 367
 368                         try {
 369                                 File.Create (path).Close ();
 370                                 FileInfo info = new FileInfo (path);
 371                                 foreach (char c in Path.InvalidPathChars)
 372                                         path2 += c;
 373                                 try {
 374                                         info.CopyTo (path2);
 375                                         Assert.Fail ("#1");
 376                                 } catch (ArgumentException ex) {
 377                                         // Illegal characters in path
 378                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 379                                         Assert.IsNull (ex.InnerException, "#3");
 380                                         Assert.IsNotNull (ex.Message, "#4");
 381                                         Assert.IsNull (ex.ParamName, "#5");
 382                                 }
 383                         } finally {
 384                                 DeleteFile (path);
 385                         }
 386                 }
 387
 388                 [Test] // CopyTo (String, Boolean)
 389                 public void CopyTo2 ()
 390                 {
 391                         string path1 = TempFolder + DSC + "FIT.CopyTo2.Source.Test";
 392                         string path2 = TempFolder + DSC + "FIT.CopyTo2.Dest.Test";
 393                         DeleteFile (path1);
 394                         DeleteFile (path2);
 395                         try {
 396                                 File.Create (path1).Close ();
 397                                 File.Create (path2).Close ();
 398                                 FileInfo info = new FileInfo (path1);
 399
 400                                 FileInfo info2 = info.CopyTo (path2, true);
 401                                 info = new FileInfo (path1);
 402                                 Assert.IsTrue (info.Exists, "#1");
 403                                 Assert.IsTrue (info2.Exists, "#2");
 404                         } finally {
 405                                 DeleteFile (path1);
 406                                 DeleteFile (path2);
 407                         }
 408                 }
 409
 410                 [Test] // CopyTo (String, Boolean)
 411                 public void CopyTo2_DestFileName_AlreadyExists ()
 412                 {
 413                         string path1 = TempFolder + DSC + "FIT.CopyToException.Source.Test";
 414                         string path2 = TempFolder + DSC + "FIT.CopyToException.Dest.Test";
 415
 416                         try {
 417                                 DeleteFile (path1);
 418                                 DeleteFile (path2);
 419                                 File.Create (path1).Close ();
 420                                 File.Create (path2).Close ();
 421                                 FileInfo info = new FileInfo (path1);
 422                                 try {
 423                                         info.CopyTo (path2, false);
 424                                         Assert.Fail ("#1");
 425                                 } catch (IOException ex) {
 426                                         // The file '...' already exists.
 427                                         Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");
 428                                         Assert.IsNull (ex.InnerException, "#3");
 429                                         Assert.IsNotNull (ex.Message, "#4");
 430                                         Assert.IsTrue (ex.Message.IndexOf (path2) != -1, "#5");
 431                                 }
 432                         } finally {
 433                                 DeleteFile (path1);
 434                                 DeleteFile (path2);
 435                         }
 436                 }
 437
 438                 [Test] // CopyTo (String, Boolean)
 439                 public void CopyTo2_DestFileName_Null ()
 440                 {
 441                         string path = TempFolder + DSC + "FIT.CopyToArgumentNullException.Test";
 442                         DeleteFile (path);
 443                         try {
 444                                 File.Create (path).Close ();
 445                                 FileInfo info = new FileInfo (path);
 446                                 try {
 447                                         info.CopyTo (null, false);
 448                                         Assert.Fail ("#1");
 449                                 } catch (ArgumentNullException ex) {
 450                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 451                                         Assert.IsNull (ex.InnerException, "#3");
 452                                         Assert.IsNotNull (ex.Message, "#4");
 453                                         Assert.AreEqual ("destFileName", ex.ParamName, "#5");
 454                                 }
 455                         } finally {
 456                                 DeleteFile (path);
 457                         }
 458                 }
 459
 460                 [Test] // CopyTo (String, Boolean)
 461                 public void CopyTo2_DestFileName_Empty ()
 462                 {
 463                         string path = TempFolder + DSC + "FIT.CopyToArgument1Exception.Test";
 464                         DeleteFile (path);
 465
 466                         try {
 467                                 File.Create (path).Close ();
 468                                 FileInfo info = new FileInfo (path);
 469                                 try {
 470                                         info.CopyTo (string.Empty, false);
 471                                         Assert.Fail ("#1");
 472                                 } catch (ArgumentException ex) {
 473                                         // Empty file name is not legal
 474                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 475                                         Assert.IsNull (ex.InnerException, "#3");
 476                                         Assert.IsNotNull (ex.Message, "#4");
 477                                         Assert.AreEqual ("destFileName", ex.ParamName, "#5");
 478                                 }
 479                         } finally {
 480                                 DeleteFile (path);
 481                         }
 482                 }
 483
 484                 [Test] // CopyTo (String, Boolean)
 485                 public void CopyTo2_DestFileName_Whitespace ()
 486                 {
 487                         string path = TempFolder + DSC + "FIT.CopyToArgument2Exception.Test";
 488                         DeleteFile (path);
 489
 490                         try {
 491                                 File.Create (path).Close ();
 492                                 FileInfo info = new FileInfo (path);
 493                                 try {
 494                                         info.CopyTo ("    ", false);
 495                                         Assert.Fail ("#1");
 496                                 } catch (ArgumentException ex) {
 497                                         // The path is not of a legal form
 498                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 499                                         Assert.IsNull (ex.InnerException, "#3");
 500                                         Assert.IsNotNull (ex.Message, "#4");
 501                                         Assert.IsNull (ex.ParamName, "#5");
 502                                 }
 503                         } finally {
 504                                 DeleteFile (path);
 505                         }
 506                 }
 507
 508                 [Test] // CopyTo (String, Boolean)
 509                 public void CopyTo2_DestFileName_InvalidPathChars ()
 510                 {
 511                         string path = TempFolder + DSC + "FIT.CopyToArgument4Exception.Test";
 512                         string path2 = string.Empty;
 513                         DeleteFile (path);
 514
 515                         try {
 516                                 File.Create (path).Close ();
 517                                 FileInfo info = new FileInfo (path);
 518                                 foreach (char c in Path.InvalidPathChars)
 519                                         path2 += c;
 520                                 try {
 521                                         info.CopyTo (path2, false);
 522                                         Assert.Fail ("#1");
 523                                 } catch (ArgumentException ex) {
 524                                         // Illegal characters in path
 525                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 526                                         Assert.IsNull (ex.InnerException, "#3");
 527                                         Assert.IsNotNull (ex.Message, "#4");
 528                                         Assert.IsNull (ex.ParamName, "#5");
 529                                 }
 530                         } finally {
 531                                 DeleteFile (path);
 532                         }
 533                 }
 534
 535                 [Test]
 536                 public void Create ()
 537                 {
 538                         string path = TempFolder + DSC + "FIT.Create.Test";
 539                         DeleteFile (path);
 540
 541                         try {
 542                                 FileInfo info = new FileInfo (path);
 543                                 Assert.IsFalse (info.Exists, "#1");
 544                                 FileStream stream = info.Create ();
 545                                 Assert.IsFalse (info.Exists, "#2");
 546                                 info = new FileInfo (path);
 547                                 Assert.IsTrue (info.Exists, "#3");
 548                                 Assert.IsTrue (stream.CanRead, "#4");
 549                                 Assert.IsTrue (stream.CanWrite, "#5");
 550                                 Assert.IsTrue (stream.CanSeek, "#6");
 551                                 stream.Close ();
 552                         } finally {
 553                                 DeleteFile (path);
 554                         }
 555                 }
 556
 557                 [Test]
 558                 public void CreateText ()
 559                 {
 560                         string path = TempFolder + DSC + "FIT.CreateText.Test";
 561                         DeleteFile (path);
 562
 563                         try {
 564                                 FileInfo info = new FileInfo (path);
 565                                 Assert.IsFalse (info.Exists, "#1");
 566                                 StreamWriter writer = info.CreateText ();
 567                                 writer.WriteLine ("test");
 568                                 writer.Close ();
 569                                 info = new FileInfo (path);
 570                                 Assert.IsTrue (info.Exists, "#2");
 571                         } finally {
 572                                 DeleteFile (path);
 573                         }
 574                 }
 575
 576                 [Test]
 577                 public void CreateText_Directory ()
 578                 {
 579                         FileInfo info = new FileInfo (TempFolder);
 580                         try {
 581                                 info.CreateText ();
 582                                 Assert.Fail ("#1");
 583                         } catch (UnauthorizedAccessException ex) {
 584                                 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#2");
 585                                 Assert.IsNull (ex.InnerException, "#3");
 586                                 Assert.IsNotNull (ex.Message, "#4");
 587                         }
 588                 }
 589
 590                 [Test]
 591                 public void Delete ()
 592                 {
 593                         string path = TempFolder + DSC + "FIT.Delete.Test";
 594                         DeleteFile (path);
 595
 596                         try {
 597                                 FileInfo info = new FileInfo (path);
 598                                 Assert.IsFalse (info.Exists, "#1");
 599                                 info.Create ().Close ();
 600                                 info = new FileInfo (path);
 601                                 Assert.IsTrue (info.Exists, "#2");
 602                                 info.Delete ();
 603                                 Assert.IsTrue (info.Exists, "#3");
 604                                 info = new FileInfo (path);
 605                                 Assert.IsFalse (info.Exists, "#4");
 606                         } finally {
 607                                 DeleteFile (path);
 608                         }
 609                 }
 610
 611                 [Test]
 612                 public void Delete_Directory ()
 613                 {
 614                         FileInfo info = new FileInfo (TempFolder);
 615                         try {
 616                                 info.Delete ();
 617                                 Assert.Fail ("#1");
 618                         } catch (UnauthorizedAccessException ex) {
 619                                 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#2");
 620                                 Assert.IsNull (ex.InnerException, "#3");
 621                                 Assert.IsNotNull (ex.Message, "#4");
 622                         }
 623                 }
 624
 625                 [Test]
 626                 public void MoveTo ()
 627                 {
 628                         string path1 = TempFolder + DSC + "FIT.MoveTo.Source.Test";
 629                         string path2 = TempFolder + DSC + "FIT.MoveTo.Dest.Test";
 630                         DeleteFile (path1);
 631                         DeleteFile (path2);
 632
 633                         try {
 634                                 File.Create (path1).Close ();
 635                                 FileInfo info1 = new FileInfo (path1);
 636                                 FileInfo info2 = new FileInfo (path2);
 637                                 Assert.IsTrue (info1.Exists, "#A1");
 638                                 Assert.AreEqual (path1, info1.FullName, "#A2");
 639                                 Assert.IsFalse (info2.Exists, "#A3");
 640                                 Assert.AreEqual (path2, info2.FullName, "#A4");
 641
 642                                 info1.MoveTo (path2);
 643                                 info2 = new FileInfo (path2);
 644                                 Assert.IsTrue (info1.Exists, "#B1");
 645                                 Assert.AreEqual (path2, info1.FullName, "#B2");
 646                                 Assert.IsTrue (info2.Exists, "#B3");
 647                                 Assert.AreEqual (path2, info2.FullName, "#B4");
 648                         } finally {
 649                                 DeleteFile (path1);
 650                                 DeleteFile (path2);
 651                         }
 652                 }
 653
 654                 [Test] //Covers #18361
 655                 public void MoveTo_SameName ()
 656                 {
 657                         string name = "FIT.MoveTo.SameName.Test";
 658                         string path1 = TempFolder + DSC + name;
 659                         string path2 = name;
 660                         DeleteFile (path1);
 661                         DeleteFile (path2);
 662
 663                         try {
 664                                 File.Create (path1).Close ();
 665                                 FileInfo info1 = new FileInfo (path1);
 666                                 FileInfo info2 = new FileInfo (path2);
 667                                 Assert.IsTrue (info1.Exists, "#A1");
 668                                 Assert.IsFalse (info2.Exists, "#A2");
 669
 670                                 info1.MoveTo (path2);
 671                                 info1 = new FileInfo (path1);
 672                                 info2 = new FileInfo (path2);
 673                                 Assert.IsFalse (info1.Exists, "#B1");
 674                                 Assert.IsTrue (info2.Exists, "#B2");
 675                         } finally {
 676                                 DeleteFile (path1);
 677                                 DeleteFile (path2);
 678                         }
 679                 }
 680
 681                 [Test]
 682                 public void MoveTo_DestFileName_AlreadyExists ()
 683                 {
 684                         string sourceFile = TempFolder + DSC + "FIT.MoveTo.Source.Test";
 685                         string destFile;
 686                         FileInfo info;
 687
 688                         // move to same directory
 689                         File.Create (sourceFile).Close ();
 690                         info = new FileInfo (sourceFile);
 691                         try {
 692                                 info.MoveTo (TempFolder);
 693                                 Assert.Fail ("#A1");
 694                         } catch (IOException ex) {
 695                                 // Cannot create a file when that file already exists
 696                                 Assert.AreEqual (typeof (IOException), ex.GetType (), "#A2");
 697                                 Assert.IsNull (ex.InnerException, "#A3");
 698                                 Assert.IsNotNull (ex.Message, "#A4");
 699                                 Assert.IsFalse (ex.Message.IndexOf (sourceFile) != -1, "#A5");
 700                                 Assert.IsFalse (ex.Message.IndexOf (TempFolder) != -1, "#A6");
 701                         } finally {
 702                                 DeleteFile (sourceFile);
 703                         }
 704
 705                         // move to exist file
 706                         File.Create (sourceFile).Close ();
 707                         destFile = TempFolder + DSC + "FIT.MoveTo.Dest.Test";
 708                         File.Create (destFile).Close ();
 709                         info = new FileInfo (sourceFile);
 710                         try {
 711                                 info.MoveTo (destFile);
 712                                 Assert.Fail ("#B1");
 713                         } catch (IOException ex) {
 714                                 // Cannot create a file when that file already exists
 715                                 Assert.AreEqual (typeof (IOException), ex.GetType (), "#B2");
 716                                 Assert.IsNull (ex.InnerException, "#B3");
 717                                 Assert.IsNotNull (ex.Message, "#B4");
 718                                 Assert.IsFalse (ex.Message.IndexOf (sourceFile) != -1, "#B5");
 719                                 Assert.IsFalse (ex.Message.IndexOf (destFile) != -1, "#B6");
 720                         } finally {
 721                                 DeleteFile (sourceFile);
 722                                 DeleteFile (destFile);
 723                         }
 724
 725                         // move to existing directory
 726                         File.Create (sourceFile).Close ();
 727                         destFile = TempFolder + Path.DirectorySeparatorChar + "bar";
 728                         Directory.CreateDirectory (destFile);
 729                         info = new FileInfo (sourceFile);
 730                         try {
 731                                 info.MoveTo (destFile);
 732                                 Assert.Fail ("#C1");
 733                         } catch (IOException ex) {
 734                                 // Cannot create a file when that file already exists
 735                                 Assert.AreEqual (typeof (IOException), ex.GetType (), "#C2");
 736                                 Assert.IsNull (ex.InnerException, "#C3");
 737                                 Assert.IsNotNull (ex.Message, "#C4");
 738                                 Assert.IsFalse (ex.Message.IndexOf (sourceFile) != -1, "#C5");
 739                                 Assert.IsFalse (ex.Message.IndexOf (destFile) != -1, "#C6");
 740                         } finally {
 741                                 DeleteFile (sourceFile);
 742                                 DeleteDirectory (destFile);
 743                         }
 744                 }
 745
 746                 [Test]
 747                 public void MoveTo_DestFileName_DirectoryDoesNotExist ()
 748                 {
 749                         string sourceFile = TempFolder + Path.DirectorySeparatorChar + "foo";
 750                         string destFile = Path.Combine (Path.Combine (TempFolder, "doesnotexist"), "b");
 751                         DeleteFile (sourceFile);
 752                         try {
 753                                 File.Create (sourceFile).Close ();
 754                                 FileInfo info = new FileInfo (sourceFile);
 755                                 try {
 756                                         info.MoveTo (destFile);
 757                                         Assert.Fail ("#1");
 758                                 } catch (DirectoryNotFoundException ex) {
 759                                         // Could not find a part of the path
 760                                         Assert.AreEqual (typeof (DirectoryNotFoundException), ex.GetType (), "#2");
 761                                         Assert.IsNull (ex.InnerException, "#3");
 762                                         Assert.IsNotNull (ex.Message, "#4");
 763                                 }
 764                         } finally {
 765                                 DeleteFile (sourceFile);
 766                         }
 767                 }
 768
 769                 [Test]
 770                 public void MoveTo_DestFileName_Null ()
 771                 {
 772                         string path = TempFolder + DSC + "FIT.MoveToArgumentNullException.Test";
 773                         DeleteFile (path);
 774
 775                         try {
 776                                 File.Create (path).Close ();
 777                                 FileInfo info = new FileInfo (path);
 778                                 try {
 779                                         info.MoveTo (null);
 780                                         Assert.Fail ("#1");
 781                                 } catch (ArgumentNullException ex) {
 782                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 783                                         Assert.IsNull (ex.InnerException, "#3");
 784                                         Assert.IsNotNull (ex.Message, "#4");
 785                                         Assert.AreEqual ("destFileName", ex.ParamName, "#5");
 786                                 }
 787                         } finally {
 788                                 DeleteFile (path);
 789                         }
 790                 }
 791
 792                 [Test]
 793                 public void MoveTo_DestFileName_Empty ()
 794                 {
 795                         string path = TempFolder + DSC + "FIT.MoveToArgumentException.Test";
 796                         DeleteFile (path);
 797
 798                         try {
 799                                 File.Create (path).Close ();
 800                                 FileInfo info = new FileInfo (path);
 801                                 try {
 802                                         info.MoveTo (string.Empty);
 803                                         Assert.Fail ("#1");
 804                                 } catch (ArgumentException ex) {
 805                                         // Empty file name is not legal
 806                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 807                                         Assert.IsNull (ex.InnerException, "#3");
 808                                         Assert.IsNotNull (ex.Message, "#4");
 809                                         Assert.AreEqual ("destFileName", ex.ParamName, "#5");
 810                                 }
 811                         } finally {
 812                                 DeleteFile (path);
 813                         }
 814                 }
 815
 816                 [Test]
 817                 public void MoveTo_DestFileName_Whitespace ()
 818                 {
 819                         string path = TempFolder + DSC + "FIT.MoveToArgumentException.Test";
 820                         DeleteFile (path);
 821
 822                         try {
 823                                 File.Create (path).Close ();
 824                                 FileInfo info = new FileInfo (path);
 825                                 try {
 826                                         info.MoveTo ("   ");
 827                                         Assert.Fail ("#1");
 828                                 } catch (ArgumentException ex) {
 829                                         // The path is not of a legal form
 830                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 831                                         Assert.IsNull (ex.InnerException, "#3");
 832                                         Assert.IsNotNull (ex.Message, "#4");
 833                                         Assert.IsNull (ex.ParamName, "#5");
 834                                 }
 835                         } finally {
 836                                 DeleteFile (path);
 837                         }
 838                 }
 839
 840                 [Test]
 841                 public void MoveTo_FileDoesNotExist ()
 842                 {
 843                         string path1 = TempFolder + DSC + "FIT.MoveToFileNotFoundException.Src";
 844                         string path2 = TempFolder + DSC + "FIT.MoveToFileNotFoundException.Dst";
 845                         DeleteFile (path1);
 846                         DeleteFile (path2);
 847
 848                         try {
 849                                 FileInfo info = new FileInfo (path1);
 850                                 try {
 851                                         info.MoveTo (path2);
 852                                         Assert.Fail ("#1");
 853                                 } catch (FileNotFoundException ex) {
 854                                         // Unable to find the specified file
 855                                         Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#2");
 856                                         Assert.IsNull (ex.FileName, "#2");
 857                                         Assert.IsNull (ex.InnerException, "#3");
 858                                         Assert.IsNotNull (ex.Message, "#4");
 859                                 }
 860                         } finally {
 861                                 DeleteFile (path1);
 862                                 DeleteFile (path2);
 863                         }
 864                 }
 865
 866                 [Test]
 867                 public void MoveTo_Same ()
 868                 {
 869                         string path = TempFolder + DSC + "FIT.MoveToSame.Test";
 870                         DeleteFile (path);
 871
 872                         try {
 873                                 File.Create (path).Close ();
 874                                 FileInfo info = new FileInfo (path);
 875                                 info.MoveTo (path);
 876                                 Assert.IsTrue (info.Exists, "#1");
 877                                 Assert.IsTrue (File.Exists (path), "#2");
 878                         } finally {
 879                                 DeleteFile (path);
 880                         }
 881                 }
 882
 883                 [Test] //Covers #38796
 884                 public void ToStringAfterMoveTo ()
 885                 {
 886                         string name1 = "FIT.ToStringAfterMoveTo.Test";
 887                         string name2 = "FIT.ToStringAfterMoveTo.Test.Alt";
 888                         string path1 = TempFolder + DSC + name1;
 889                         string path2 = TempFolder + DSC + name2;
 890                         DeleteFile (path1);
 891                         DeleteFile (path2);
 892
 893                         try {
 894                                 File.Create (path1).Close ();
 895                                 FileInfo info = new FileInfo (path1);
 896                                 Assert.AreEqual (path1, info.ToString (), "#A");
 897
 898                                 info.MoveTo (path2);
 899                                 Assert.AreEqual (path2, info.ToString (), "#B");
 900                         } finally {
 901                                 DeleteFile (path1);
 902                                 DeleteFile (path2);
 903                         }
 904                 }
 905
 906 #if !MOBILE
 907                 [Test]
 908                 public void Replace1 ()
 909                 {
 910                         string path1 = TempFolder + DSC + "FIT.Replace.Source.Test";
 911                         string path2 = TempFolder + DSC + "FIT.Replace.Dest.Test";
 912                         string path3 = TempFolder + DSC + "FIT.Replace.Back.Test";
 913
 914                         DeleteFile (path1);
 915                         DeleteFile (path2);
 916                         DeleteFile (path3);
 917                         try {
 918                                 File.Create (path1).Close ();
 919                                 File.Create (path2).Close ();
 920                                 File.Create (path3).Close ();
 921                                 FileInfo info = new FileInfo (path1);
 922                                 Assert.IsTrue (info.Exists, "#1");
 923                                 FileInfo info2 = info.Replace (path2, path3);
 924                                 Assert.IsTrue (info2.Exists, "#2");
 925                                 FileInfo info3 = new FileInfo (path3);
 926                                 Assert.IsTrue (info3.Exists, "#3");
 927                         } finally {
 928                                 DeleteFile (path2);
 929                                 DeleteFile (path3);
 930                         }
 931                 }
 932
 933                 [Test]
 934                 public void Replace1_Backup_Null ()
 935                 {
 936                         string path1 = TempFolder + DSC + "FIT.Replace.Source.Test";
 937                         string path2 = TempFolder + DSC + "FIT.Replace.Dest.Test";
 938
 939                         DeleteFile (path1);
 940                         DeleteFile (path2);
 941                         try {
 942                                 File.Create (path1).Close ();
 943                                 File.Create (path2).Close ();
 944                                 FileInfo info = new FileInfo (path1);
 945                                 Assert.IsTrue (info.Exists, "#1");
 946                                 FileInfo info2 = info.Replace (path2, null);
 947                                 Assert.IsTrue (info2.Exists, "#2");
 948                                 info = new FileInfo (path1);
 949                                 Assert.IsFalse (info.Exists, "#3");
 950                         } finally {
 951                                 DeleteFile (path2);
 952                         }
 953                 }
 954
 955                 [Test]
 956                 public void Replace1_DestFileName_Null ()
 957                 {
 958                         string path1 = TempFolder + DSC + "FIT.Replace.Source.Test";
 959                         DeleteFile (path1);
 960                         try {
 961                                 try {
 962                                         File.Create (path1).Close ();
 963                                         FileInfo info = new FileInfo (path1);
 964                                         info.Replace (null, null);
 965                                         Assert.Fail ("#1");
 966                                 } catch (ArgumentNullException ex) {
 967                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 968                                         Assert.IsNull (ex.InnerException, "#3");
 969                                         Assert.IsNotNull (ex.Message, "#4");
 970                                 }
 971                         } finally {
 972                                 DeleteFile (path1);
 973                         }
 974                 }
 975
 976                 [Test]
 977                 public void Replace1_DestFileName_Empty ()
 978                 {
 979                         string path1 = TempFolder + DSC + "FIT.Replace.Source.Test";
 980                         DeleteFile (path1);
 981                         try {
 982                                 try {
 983                                         File.Create (path1).Close ();
 984                                         FileInfo info = new FileInfo (path1);
 985                                         info.Replace (string.Empty, null);
 986                                         Assert.Fail ("#1");
 987                                 } catch (ArgumentException ex) {
 988                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 989                                         Assert.IsNull (ex.InnerException, "#3");
 990                                         Assert.IsNotNull (ex.Message, "#4");
 991                                 }
 992                         } finally {
 993                                 DeleteFile (path1);
 994                         }
 995                 }
 996
 997                 [Test]
 998                 public void Replace1_DestFileName_WhiteSpace ()
 999                 {
1000                         string path1 = TempFolder + DSC + "FIT.Replace.Source.Test";
1001                         DeleteFile (path1);
1002                         try {
1003                                 try {
1004                                         File.Create (path1).Close ();
1005                                         FileInfo info = new FileInfo (path1);
1006                                         info.Replace ("     ", null);
1007                                         Assert.Fail ("#1");
1008                                 } catch (ArgumentException ex) {
1009                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1010                                         Assert.IsNull (ex.InnerException, "#3");
1011                                         Assert.IsNotNull (ex.Message, "#4");
1012                                 }
1013                         } finally {
1014                                 DeleteFile (path1);
1015                         }
1016                 }
1017
1018                 [Test]
1019                 public void Replace1_DestFileName_InvalidPathChars ()
1020                 {
1021                         string path1 = TempFolder + DSC + "FIT.Replace.Source.Test";
1022                         string path2 = string.Empty;
1023                         DeleteFile (path1);
1024
1025                         try {
1026                                 File.Create (path1).Close ();
1027                                 FileInfo info = new FileInfo (path1);
1028                                 foreach (char c in Path.InvalidPathChars)
1029                                         path2 += c;
1030                                 try {
1031                                         info.Replace (path2, null);
1032                                         Assert.Fail ("#1");
1033                                 } catch (ArgumentException ex) {
1034                                         // Illegal characters in path
1035                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1036                                         Assert.IsNull (ex.InnerException, "#3");
1037                                         Assert.IsNotNull (ex.Message, "#4");
1038                                         Assert.IsNull (ex.ParamName, "#5");
1039                                 }
1040                         } finally {
1041                                 DeleteFile (path1);
1042                         }
1043                 }
1044
1045                 [Test]
1046                 public void Replace1_DestFileName_FileNotFound ()
1047                 {
1048                         string path1 = TempFolder + DSC + "FIT.Replace.Source.Test";
1049                         string path2 = TempFolder + DSC + "FIT.Replace.Dest.Test";
1050                         DeleteFile (path1);
1051                         DeleteFile (path2);
1052
1053                         try {
1054                                 try {
1055                                         File.Create (path1).Close ();
1056                                         FileInfo info = new FileInfo (path1);
1057                                         info.Replace (path2, null);
1058                                         Assert.Fail ("#1");
1059                                 } catch (FileNotFoundException ex) {
1060                                         Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#2");
1061                                         Assert.IsNull (ex.InnerException, "#3");
1062                                         Assert.IsNotNull (ex.Message, "#4");
1063                                 }
1064                         } finally {
1065                                 DeleteFile (path1);
1066                         }
1067                 }
1068
1069                 [Test]
1070                 public void Replace1_DestFileName_IsReadOnly ()
1071                 {
1072                         string path1 = TempFolder + DSC + "FIT.Replace.Source.Test";
1073                         string path2 = TempFolder + DSC + "FIT.Replace.Dest.Test";
1074                         DeleteFile (path1);
1075                         DeleteFile (path2);
1076
1077                         try {
1078                                 try {
1079                                         File.Create (path1).Close ();
1080                                         File.Create (path2).Close ();
1081                                         File.SetAttributes (path2, FileAttributes.ReadOnly);
1082                                         FileInfo info = new FileInfo (path1);
1083                                         info.Replace (path2, null);
1084                                         Assert.Fail ("#1");
1085                                 } catch (UnauthorizedAccessException ex) {
1086                                         Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#2");
1087                                         Assert.IsNull (ex.InnerException, "#3");
1088                                         Assert.IsNotNull (ex.Message, "#4");
1089                                 }
1090                         } finally {
1091                                 File.SetAttributes (path2, FileAttributes.Normal);
1092                                 DeleteFile (path1);
1093                                 DeleteFile (path2);
1094                         }
1095                 }
1096
1097                 [Test]
1098                 public void Replace1_Source_FileNotFound ()
1099                 {
1100                         string path1 = TempFolder + DSC + "FIT.Replace.Source.Test";
1101                         string path2 = TempFolder + DSC + "FIT.Replace.Dest.Test";
1102                         DeleteFile (path2);
1103
1104                         try {
1105                                 try {
1106                                         File.Create (path2).Close ();
1107                                         FileInfo info = new FileInfo (path1);
1108                                         info.Replace (path2, null);
1109                                         Assert.Fail ("#1");
1110                                 } catch (FileNotFoundException ex) {
1111                                         Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#2");
1112                                         Assert.IsNull (ex.InnerException, "#3");
1113                                         Assert.IsNotNull (ex.Message, "#4");
1114                                 }
1115                         } finally {
1116                                 DeleteFile (path2);
1117                         }
1118                 }
1119 #endif
1120
1121                 [Test]
1122                 public void Open ()
1123                 {
1124                         string path = TempFolder + DSC + "FIT.Open.Test";
1125                         DeleteFile (path);
1126                         FileStream stream = null;
1127                         try {
1128                                 FileInfo info = new FileInfo (path);
1129                                 stream = info.Open (FileMode.CreateNew);
1130                                 Assert.IsTrue (stream.CanRead, "#A1");
1131                                 Assert.IsTrue (stream.CanSeek, "#A2");
1132                                 Assert.IsTrue (stream.CanWrite, "#A3");
1133                                 stream.Close ();
1134
1135                                 stream = info.Open (FileMode.Open);
1136                                 Assert.IsTrue (stream.CanRead, "#B1");
1137                                 Assert.IsTrue (stream.CanSeek, "#B2");
1138                                 Assert.IsTrue (stream.CanWrite, "#B3");
1139                                 stream.Close ();
1140
1141                                 stream = info.Open (FileMode.Append, FileAccess.Write);
1142                                 Assert.IsFalse (stream.CanRead, "#C1");
1143                                 Assert.IsTrue (stream.CanSeek, "#C2");
1144                                 Assert.IsTrue (stream.CanWrite, "#C3");
1145                                 stream.Close ();
1146
1147                                 stream = info.Open (FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
1148                                 Assert.IsTrue (stream.CanRead, "#D1");
1149                                 Assert.IsTrue (stream.CanSeek, "#D2");
1150                                 Assert.IsTrue (stream.CanWrite, "#D3");
1151                                 stream.Close ();
1152                         } finally {
1153                                 if (stream != null)
1154                                         stream.Close ();
1155                                 DeleteFile (path);
1156                         }
1157                 }
1158
1159                 [Test]
1160                 public void Open_FileDoesNotExist ()
1161                 {
1162                         string path = TempFolder + DSC + "FIT.OpenFileNotFoundException.Test";
1163                         DeleteFile (path);
1164
1165                         FileInfo info = new FileInfo (path);
1166                         try {
1167                                 info.Open (FileMode.Open);
1168                                 Assert.Fail ("#1");
1169                         } catch (FileNotFoundException ex) {
1170                                 Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#2");
1171                                 Assert.AreEqual (path, ex.FileName, "#3");
1172                                 Assert.IsNull (ex.InnerException, "#4");
1173                                 Assert.IsNotNull (ex.Message, "#5");
1174                         }
1175                 }
1176
1177                 [Test]
1178                 public void OpenRead ()
1179                 {
1180                         string path = TempFolder + DSC + "FIT.OpenRead.Test";
1181                         DeleteFile (path);
1182                         FileStream stream = null;
1183                         try {
1184                                 File.Create (path).Close ();
1185                                 FileInfo info = new FileInfo (path);
1186                                 stream = info.OpenRead ();
1187                                 Assert.IsTrue (stream.CanRead, "#1");
1188                                 Assert.IsTrue (stream.CanSeek, "#2");
1189                                 Assert.IsFalse (stream.CanWrite, "#3");
1190                                 stream.Close ();
1191
1192                         } finally {
1193                                 if (stream != null)
1194                                         stream.Close ();
1195                                 DeleteFile (path);
1196                         }
1197                 }
1198
1199                 [Test]
1200                 public void OpenRead_FileLock ()
1201                 {
1202                         string path = TempFolder + DSC + "FIT.OpenReadIOException.Test";
1203                         DeleteFile (path);
1204                         FileStream stream = null;
1205
1206                         try {
1207                                 stream = File.Create (path);
1208                                 FileInfo info = new FileInfo (path);
1209                                 try {
1210                                         info.OpenRead ();
1211                                         Assert.Fail ("#1");
1212                                 } catch (IOException ex) {
1213                                         // The process cannot access the file because
1214                                         // it is being used by another process
1215                                         Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");
1216                                         Assert.IsNull (ex.InnerException, "#3");
1217                                         Assert.IsNotNull (ex.Message, "#4");
1218                                 }
1219                         } finally {
1220                                 if (stream != null)
1221                                         stream.Close ();
1222                                 DeleteFile (path);
1223                         }
1224                 }
1225
1226                 [Test]
1227                 public void OpenRead_Directory ()
1228                 {
1229                         FileInfo info = new FileInfo (TempFolder);
1230                         try {
1231                                 info.OpenRead ();
1232                                 Assert.Fail ("#1");
1233                         } catch (UnauthorizedAccessException ex) {
1234                                 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#2");
1235                                 Assert.IsNull (ex.InnerException, "#3");
1236                                 Assert.IsNotNull (ex.Message, "#4");
1237                         }
1238                 }
1239
1240                 [Test]
1241                 public void OpenText ()
1242                 {
1243                         string path = TempFolder + DSC + "FIT.OpenText.Test";
1244                         DeleteFile (path);
1245                         StreamReader reader = null;
1246                         try {
1247                                 File.Create (path).Close ();
1248                                 FileInfo info = new FileInfo (path);
1249                                 reader = info.OpenText ();
1250                                 Assert.AreEqual (-1, reader.Peek ());
1251                         } finally {
1252                                 if (reader != null)
1253                                         reader.Close ();
1254                                 DeleteFile (path);
1255                         }
1256                 }
1257
1258                 [Test]
1259                 public void OpenText_FileDoesNotExist ()
1260                 {
1261                         string path = TempFolder + DSC + "FIT.OpenTextFileNotFoundException.Test";
1262                         DeleteFile (path);
1263                         FileInfo info = new FileInfo (path);
1264                         try {
1265                                 info.OpenText ();
1266                                 Assert.Fail ("#1");
1267                         } catch (FileNotFoundException ex) {
1268                                 Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#2");
1269                                 Assert.AreEqual (path, ex.FileName, "#3");
1270                                 Assert.IsNull (ex.InnerException, "#4");
1271                                 Assert.IsNotNull (ex.Message, "#5");
1272                         }
1273                 }
1274
1275                 [Test]
1276                 public void OpenText_Directory ()
1277                 {
1278                         FileInfo info = new FileInfo (TempFolder);
1279                         try {
1280                                 info.OpenText ();
1281                                 Assert.Fail ("#1");
1282                         } catch (UnauthorizedAccessException ex) {
1283                                 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#2");
1284                                 Assert.IsNull (ex.InnerException, "#3");
1285                                 Assert.IsNotNull (ex.Message, "#4");
1286                         }
1287                 }
1288
1289                 [Test]
1290                 public void OpenWrite ()
1291                 {
1292                         string path = TempFolder + DSC + "FIT.OpenWrite.Test";
1293                         DeleteFile (path);
1294                         FileStream stream = null;
1295                         try {
1296                                 File.Create (path).Close ();
1297                                 FileInfo info = new FileInfo (path);
1298                                 stream = info.OpenWrite ();
1299                                 Assert.IsFalse (stream.CanRead, "#1");
1300                                 Assert.IsTrue (stream.CanSeek, "#2");
1301                                 Assert.IsTrue (stream.CanWrite, "#3");
1302                         } finally {
1303                                 if (stream != null)
1304                                         stream.Close ();
1305                                 DeleteFile (path);
1306                         }
1307                 }
1308
1309                 [Test]
1310                 public void OpenWrite_Directory ()
1311                 {
1312                         FileInfo info = new FileInfo (TempFolder);
1313                         try {
1314                                 info.OpenWrite ();
1315                                 Assert.Fail ("#1");
1316                         } catch (UnauthorizedAccessException ex) {
1317                                 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#2");
1318                                 Assert.IsNull (ex.InnerException, "#3");
1319                                 Assert.IsNotNull (ex.Message, "#4");
1320                         }
1321                 }
1322 #if !MOBILE
1323                 [Test]
1324                 public void Serialization ()
1325                 {
1326                         FileInfo info;
1327                         SerializationInfo si;
1328
1329                         info = new FileInfo ("Test");
1330                         si = new SerializationInfo (typeof (FileInfo), new FormatterConverter ());
1331                         info.GetObjectData (si, new StreamingContext ());
1332
1333                         Assert.AreEqual (2, si.MemberCount, "#A1");
1334                         Assert.AreEqual ("Test", si.GetString ("OriginalPath"), "#A2");
1335                         Assert.AreEqual (Path.Combine (Directory.GetCurrentDirectory (), "Test"), si.GetString ("FullPath"), "#A3");
1336
1337                         info = new FileInfo (TempFolder);
1338                         si = new SerializationInfo (typeof (FileInfo), new FormatterConverter ());
1339                         info.GetObjectData (si, new StreamingContext ());
1340
1341                         Assert.AreEqual (2, si.MemberCount, "#B1");
1342                         Assert.AreEqual (TempFolder, si.GetString ("OriginalPath"), "#B2");
1343                         Assert.AreEqual (TempFolder, si.GetString ("FullPath"), "#B3");
1344                 }
1345
1346                 [Test]
1347                 public void Deserialization ()
1348                 {
1349                         FileInfo info = new FileInfo ("Test");
1350
1351                         MemoryStream ms = new MemoryStream ();
1352                         BinaryFormatter bf = new BinaryFormatter ();
1353                         bf.Serialize (ms, info);
1354                         ms.Position = 0;
1355
1356                         FileInfo clone = (FileInfo) bf.Deserialize (ms);
1357                         Assert.AreEqual (info.Name, clone.Name, "#1");
1358                         Assert.AreEqual (info.FullName, clone.FullName, "#2");
1359                 }
1360 #endif
1361
1362                 [Test]
1363                 [Category ("MobileNotWorking")]
1364                 public void ToStringVariety ()
1365                 {
1366                         Assert.AreEqual ("foo", new FileInfo ("foo").ToString ());
1367                         Assert.AreEqual ("c:/foo", new FileInfo ("c:/foo").ToString ());
1368                         Assert.AreEqual ("/usr/local/foo", new FileInfo ("/usr/local/foo").ToString ());
1369                         Assert.AreEqual ("c:\\foo", new FileInfo ("c:\\foo").ToString ());
1370                         Assert.AreEqual ("/usr/local\\foo", new FileInfo ("/usr/local\\foo").ToString ());
1371                         Assert.AreEqual ("foo/BAR/baz", new FileInfo ("foo/BAR/baz").ToString ());
1372                         Assert.AreEqual ("c:/documents and settings", new FileInfo ("c:/documents and settings").ToString ());
1373                         Assert.AreEqual ("c:/docUme~1", new FileInfo ("c:/docUme~1").ToString ());
1374                 }
1375
1376                 void DeleteFile (string path)
1377                 {
1378                         if (File.Exists (path))
1379                                 File.Delete (path);
1380                 }
1381
1382                 void DeleteDirectory (string path)
1383                 {
1384                         if (Directory.Exists (path))
1385                                 Directory.Delete (path, true);
1386                 }
1387         }
1388 }