mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-18 17:02:10 -10:00
IOException if specified path does not exist. Fixes bug #77641. * FileTest.cs: In 2.0 profile, no longer expect IOException when path to non-existing directory or file is specified in Get***Time(Utc) methods (bug #77641). Renamed tests and removed trailing tabs. Removed duplicate test. Fixed GetLastWriteTime(Utc) tests that used GetLastAccessTime(Utc) instead of GetLastWriteTime(Utc). * DirectoryTest.cs: No longer expect IOException when path to non-existing directory or file is specified in Get***Time(Utc) methods (bug #77641). svn path=/trunk/mcs/; revision=57338
1601 lines
49 KiB
C#
1601 lines
49 KiB
C#
//
|
|
// FileTest.cs: Test cases for System.IO.File
|
|
//
|
|
// Author:
|
|
// Duncan Mak ([email protected])
|
|
// Ville Palo ([email protected])
|
|
//
|
|
// (C) 2002 Ximian, Inc. http://www.ximian.com
|
|
//
|
|
// TODO: Find out why ArgumentOutOfRangeExceptions does not manage to close streams properly
|
|
//
|
|
using NUnit.Framework;
|
|
using System;
|
|
using System.IO;
|
|
using System.Globalization;
|
|
using System.Threading;
|
|
|
|
namespace MonoTests.System.IO
|
|
{
|
|
[TestFixture]
|
|
public class FileTest : Assertion
|
|
{
|
|
static string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");
|
|
|
|
[SetUp]
|
|
public void SetUp ()
|
|
{
|
|
if (Directory.Exists (TempFolder))
|
|
Directory.Delete (TempFolder, true);
|
|
Directory.CreateDirectory (TempFolder);
|
|
|
|
Thread.CurrentThread.CurrentCulture = new CultureInfo ("EN-us");
|
|
}
|
|
|
|
[TearDown]
|
|
public void TearDown ()
|
|
{
|
|
if (Directory.Exists (TempFolder))
|
|
Directory.Delete (TempFolder, true);
|
|
}
|
|
|
|
[Test]
|
|
public void TestExists ()
|
|
{
|
|
int i = 0;
|
|
FileStream s = null;
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "AFile.txt";
|
|
try {
|
|
Assert ("null filename should not exist", !File.Exists (null));
|
|
i++;
|
|
Assert ("empty filename should not exist", !File.Exists (""));
|
|
i++;
|
|
Assert ("whitespace filename should not exist", !File.Exists (" \t\t \t \n\t\n \n"));
|
|
i++;
|
|
DeleteFile (path);
|
|
s = File.Create (path);
|
|
s.Close ();
|
|
Assert ("File " + path + " should exists", File.Exists (path));
|
|
i++;
|
|
Assert ("File resources" + Path.DirectorySeparatorChar + "doesnotexist should not exist", !File.Exists (TempFolder + Path.DirectorySeparatorChar + "doesnotexist"));
|
|
} catch (Exception e) {
|
|
Fail ("Unexpected exception at i = " + i + ". e=" + e);
|
|
} finally {
|
|
if (s != null)
|
|
s.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Exists_InvalidFileName ()
|
|
{
|
|
Assert ("><|", !File.Exists ("><|"));
|
|
Assert ("?*", !File.Exists ("?*"));
|
|
}
|
|
|
|
[Test]
|
|
public void Exists_InvalidDirectory ()
|
|
{
|
|
Assert ("InvalidDirectory", !File.Exists (Path.Combine ("does not exist", "file.txt")));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentNullException))]
|
|
public void CtorArgumentNullException1 ()
|
|
{
|
|
FileStream stream = File.Create (null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void CtorArgumentException1 ()
|
|
{
|
|
FileStream stream = File.Create ("");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void CtorArgumentException2 ()
|
|
{
|
|
FileStream stream = File.Create (" ");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (DirectoryNotFoundException))]
|
|
public void CtorDirectoryNotFoundException ()
|
|
{
|
|
FileStream stream = null;
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "directory_does_not_exist" + Path.DirectorySeparatorChar + "foo";
|
|
|
|
try {
|
|
stream = File.Create (path);
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestCreate ()
|
|
{
|
|
FileStream stream = null;
|
|
string path = "";
|
|
/* positive test: create resources/foo */
|
|
try {
|
|
path = TempFolder + Path.DirectorySeparatorChar + "foo";
|
|
stream = File.Create (path);
|
|
Assert ("File should exist", File.Exists (path));
|
|
stream.Close ();
|
|
} catch (Exception e) {
|
|
Fail ("File.Create(resources/foo) unexpected exception caught: e=" + e.ToString());
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
|
|
path = "";
|
|
stream = null;
|
|
|
|
/* positive test: repeat test above again to test for overwriting file */
|
|
try {
|
|
path = TempFolder + Path.DirectorySeparatorChar + "foo";
|
|
stream = File.Create (path);
|
|
Assert ("File should exist", File.Exists (path));
|
|
stream.Close ();
|
|
} catch (Exception e) {
|
|
Fail ("File.Create(resources/foo) unexpected exception caught: e=" + e.ToString());
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void CopyArgumentNullException1 ()
|
|
{
|
|
File.Copy (null, "b");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void CopyArgumentNullException2 ()
|
|
{
|
|
File.Copy ("a", null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void CopyArgumentException1 ()
|
|
{
|
|
File.Copy ("", "b");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void CopyArgumentException2 ()
|
|
{
|
|
File.Copy ("a", "");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void CopyArgumentException3 ()
|
|
{
|
|
File.Copy (" ", "b");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void CopyArgumentException4 ()
|
|
{
|
|
File.Copy ("a", " ");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(FileNotFoundException))]
|
|
public void CopyFileNotFoundException ()
|
|
{
|
|
File.Copy ("doesnotexist", "b");
|
|
}
|
|
|
|
[ExpectedException(typeof(IOException))]
|
|
public void CopyIOException ()
|
|
{
|
|
DeleteFile (TempFolder + Path.DirectorySeparatorChar + "bar");
|
|
DeleteFile (TempFolder + Path.DirectorySeparatorChar + "AFile.txt");
|
|
try {
|
|
File.Create (TempFolder + Path.DirectorySeparatorChar + "AFile.txt").Close ();
|
|
File.Copy (TempFolder + Path.DirectorySeparatorChar + "AFile.txt", TempFolder + Path.DirectorySeparatorChar + "bar");
|
|
File.Copy (TempFolder + Path.DirectorySeparatorChar + "AFile.txt", TempFolder + Path.DirectorySeparatorChar + "bar");
|
|
} finally {
|
|
DeleteFile (TempFolder + Path.DirectorySeparatorChar + "bar");
|
|
DeleteFile (TempFolder + Path.DirectorySeparatorChar + "AFile.txt");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestCopy ()
|
|
{
|
|
string path1 = TempFolder + Path.DirectorySeparatorChar + "bar";
|
|
string path2 = TempFolder + Path.DirectorySeparatorChar + "AFile.txt";
|
|
/* positive test: copy resources/AFile.txt to resources/bar */
|
|
try {
|
|
try {
|
|
DeleteFile (path1);
|
|
DeleteFile (path2);
|
|
|
|
File.Create (path2).Close ();
|
|
File.Copy (path2, path1);
|
|
Assert ("File AFile.txt should still exist", File.Exists (path2));
|
|
Assert ("File bar should exist after File.Copy", File.Exists (path1));
|
|
} catch (Exception e) {
|
|
Fail ("#1 File.Copy('resources/AFile.txt', 'resources/bar') unexpected exception caught: e=" + e.ToString());
|
|
}
|
|
|
|
/* positive test: copy resources/AFile.txt to resources/bar, overwrite */
|
|
try {
|
|
Assert ("File bar should exist before File.Copy", File.Exists (path1));
|
|
File.Copy (path2, path1, true);
|
|
Assert ("File AFile.txt should still exist", File.Exists (path2));
|
|
Assert ("File bar should exist after File.Copy", File.Exists (path1));
|
|
} catch (Exception e) {
|
|
Fail ("File.Copy('resources/AFile.txt', 'resources/bar', true) unexpected exception caught: e=" + e.ToString());
|
|
}
|
|
}finally {
|
|
DeleteFile (path1);
|
|
DeleteFile (path2);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException))]
|
|
public void DeleteArgumentNullException ()
|
|
{
|
|
File.Delete (null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void DeleteArgumentException1 ()
|
|
{
|
|
File.Delete ("");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void DeleteArgumentException2 ()
|
|
{
|
|
File.Delete (" ");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (DirectoryNotFoundException))]
|
|
public void DeleteDirectoryNotFoundException ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "directory_does_not_exist" + Path.DirectorySeparatorChar + "foo";
|
|
if (Directory.Exists (path))
|
|
Directory.Delete (path, true);
|
|
File.Delete (path);
|
|
}
|
|
|
|
|
|
[Test]
|
|
public void TestDelete ()
|
|
{
|
|
string foopath = TempFolder + Path.DirectorySeparatorChar + "foo";
|
|
DeleteFile (foopath);
|
|
try {
|
|
File.Create (foopath).Close ();
|
|
|
|
try {
|
|
File.Delete (foopath);
|
|
} catch (Exception e) {
|
|
Fail ("Unable to delete " + foopath + " e=" + e.ToString());
|
|
}
|
|
Assert ("File " + foopath + " should not exist after File.Delete", !File.Exists (foopath));
|
|
} finally {
|
|
DeleteFile (foopath);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (IOException))]
|
|
[Category("NotWorking")]
|
|
public void DeleteOpenStreamException ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "DeleteOpenStreamException";
|
|
DeleteFile (path);
|
|
FileStream stream = null;
|
|
try {
|
|
stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.ReadWrite);
|
|
File.Delete (path);
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentNullException))]
|
|
public void MoveException1 ()
|
|
{
|
|
File.Move (null, "b");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentNullException))]
|
|
public void MoveException2 ()
|
|
{
|
|
File.Move ("a", null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void MoveException3 ()
|
|
{
|
|
File.Move ("", "b");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void MoveException4 ()
|
|
{
|
|
File.Move ("a", "");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void MoveException5 ()
|
|
{
|
|
File.Move (" ", "b");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void MoveException6 ()
|
|
{
|
|
File.Move ("a", " ");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (FileNotFoundException))]
|
|
public void MoveException7 ()
|
|
{
|
|
DeleteFile (TempFolder + Path.DirectorySeparatorChar + "doesnotexist");
|
|
File.Move (TempFolder + Path.DirectorySeparatorChar + "doesnotexist", "b");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (DirectoryNotFoundException))]
|
|
public void MoveException8 ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "foo";
|
|
DeleteFile (path);
|
|
try {
|
|
File.Create (TempFolder + Path.DirectorySeparatorChar + "AFile.txt").Close ();
|
|
File.Copy(TempFolder + Path.DirectorySeparatorChar + "AFile.txt", path, true);
|
|
DeleteFile (TempFolder + Path.DirectorySeparatorChar + "doesnotexist" + Path.DirectorySeparatorChar + "b");
|
|
File.Move (TempFolder + Path.DirectorySeparatorChar + "foo", TempFolder + Path.DirectorySeparatorChar + "doesnotexist" + Path.DirectorySeparatorChar + "b");
|
|
} finally {
|
|
DeleteFile (TempFolder + Path.DirectorySeparatorChar + "AFile.txt");
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (IOException))]
|
|
public void MoveException9 ()
|
|
{
|
|
File.Create (TempFolder + Path.DirectorySeparatorChar + "foo").Close ();
|
|
try {
|
|
File.Move (TempFolder + Path.DirectorySeparatorChar + "foo", TempFolder);
|
|
} finally {
|
|
DeleteFile (TempFolder + Path.DirectorySeparatorChar + "foo");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestMove ()
|
|
{
|
|
string bar = TempFolder + Path.DirectorySeparatorChar + "bar";
|
|
string baz = TempFolder + Path.DirectorySeparatorChar + "baz";
|
|
if (!File.Exists (bar)) {
|
|
FileStream f = File.Create(bar);
|
|
f.Close();
|
|
}
|
|
|
|
Assert ("File " + TempFolder + Path.DirectorySeparatorChar + "bar should exist", File.Exists (bar));
|
|
File.Move (bar, baz);
|
|
Assert ("File " + TempFolder + Path.DirectorySeparatorChar + "bar should not exist", !File.Exists (bar));
|
|
Assert ("File " + TempFolder + Path.DirectorySeparatorChar + "baz should exist", File.Exists (baz));
|
|
|
|
// Test moving of directories
|
|
string dir = Path.Combine (TempFolder, "dir");
|
|
string dir2 = Path.Combine (TempFolder, "dir2");
|
|
string dir_foo = Path.Combine (dir, "foo");
|
|
string dir2_foo = Path.Combine (dir2, "foo");
|
|
|
|
if (Directory.Exists (dir))
|
|
Directory.Delete (dir, true);
|
|
|
|
Directory.CreateDirectory (dir);
|
|
Directory.CreateDirectory (dir2);
|
|
File.Create (dir_foo).Close ();
|
|
File.Move (dir_foo, dir2_foo);
|
|
Assert (File.Exists (dir2_foo));
|
|
|
|
Directory.Delete (dir, true);
|
|
Directory.Delete (dir2, true);
|
|
DeleteFile (dir_foo);
|
|
DeleteFile (dir2_foo);
|
|
}
|
|
|
|
[Test]
|
|
public void TestOpen ()
|
|
{
|
|
string path = "";
|
|
FileStream stream = null;
|
|
try {
|
|
path = TempFolder + Path.DirectorySeparatorChar + "AFile.txt";
|
|
if (!File.Exists (path))
|
|
stream = File.Create (path);
|
|
stream.Close ();
|
|
stream = File.Open (path, FileMode.Open);
|
|
stream.Close ();
|
|
} catch (Exception e) {
|
|
Fail ("Unable to open " + TempFolder + Path.DirectorySeparatorChar + "AFile.txt: e=" + e.ToString());
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
|
|
path = "";
|
|
stream = null;
|
|
/* Exception tests */
|
|
try {
|
|
path = TempFolder + Path.DirectorySeparatorChar + "filedoesnotexist";
|
|
stream = File.Open (path, FileMode.Open);
|
|
Fail ("File 'filedoesnotexist' should not exist");
|
|
} catch (FileNotFoundException) {
|
|
// do nothing, this is what we expect
|
|
} catch (Exception e) {
|
|
Fail ("Unexpect exception caught: e=" + e.ToString());
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Open ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "AFile.txt";
|
|
if (!File.Exists (path))
|
|
File.Create (path).Close ();
|
|
FileStream stream = null;
|
|
try {
|
|
|
|
stream = File.Open (path, FileMode.Open);
|
|
|
|
Assertion.AssertEquals ("test#01", true, stream.CanRead);
|
|
Assertion.AssertEquals ("test#02", true, stream.CanSeek);
|
|
Assertion.AssertEquals ("test#03", true, stream.CanWrite);
|
|
stream.Close ();
|
|
|
|
stream = File.Open (path, FileMode.Open, FileAccess.Write);
|
|
Assertion.AssertEquals ("test#04", false, stream.CanRead);
|
|
Assertion.AssertEquals ("test#05", true, stream.CanSeek);
|
|
Assertion.AssertEquals ("test#06", true, stream.CanWrite);
|
|
stream.Close ();
|
|
|
|
stream = File.Open (path, FileMode.Open, FileAccess.Read);
|
|
Assertion.AssertEquals ("test#04", true, stream.CanRead);
|
|
Assertion.AssertEquals ("test#05", true, stream.CanSeek);
|
|
Assertion.AssertEquals ("test#06", false, stream.CanWrite);
|
|
stream.Close ();
|
|
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void OpenException1 ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "AFile.txt";
|
|
FileStream stream = null;
|
|
// CreateNew + Read throws an exceptoin
|
|
try {
|
|
stream = File.Open (TempFolder + Path.DirectorySeparatorChar + "AFile.txt", FileMode.CreateNew, FileAccess.Read);
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void OpenException2 ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "AFile.txt";
|
|
FileStream s = null;
|
|
// Append + Read throws an exceptoin
|
|
if (!File.Exists (path))
|
|
File.Create (path).Close ();
|
|
try {
|
|
s = File.Open (path, FileMode.Append, FileAccess.Read);
|
|
} finally {
|
|
if (s != null)
|
|
s.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void OpenRead ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "AFile.txt";
|
|
if (!File.Exists (path))
|
|
File.Create (path).Close ();
|
|
FileStream stream = null;
|
|
|
|
try {
|
|
stream = File.OpenRead (path);
|
|
|
|
Assertion.AssertEquals ("test#01", true, stream.CanRead);
|
|
Assertion.AssertEquals ("test#02", true, stream.CanSeek);
|
|
Assertion.AssertEquals ("test#03", false, stream.CanWrite);
|
|
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void OpenWrite ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "AFile.txt";
|
|
if (!File.Exists (path))
|
|
File.Create (path).Close ();
|
|
FileStream stream = null;
|
|
|
|
try {
|
|
stream = File.OpenWrite (path);
|
|
Assertion.AssertEquals ("test#01", false, stream.CanRead);
|
|
Assertion.AssertEquals ("test#02", true, stream.CanSeek);
|
|
Assertion.AssertEquals ("test#03", true, stream.CanWrite);
|
|
stream.Close ();
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestGetCreationTime ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "baz";
|
|
DeleteFile (path);
|
|
|
|
try {
|
|
File.Create (path).Close();
|
|
DateTime time = File.GetCreationTime (path);
|
|
Assert ("GetCreationTime incorrect", (DateTime.Now - time).TotalSeconds < 10);
|
|
} finally {
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
// Setting the creation time on Unix is not possible
|
|
[Test]
|
|
public void CreationTime ()
|
|
{
|
|
int platform = (int) Environment.OSVersion.Platform;
|
|
if ((platform == 4) || (platform == 128))
|
|
return;
|
|
|
|
string path = Path.GetTempFileName ();
|
|
|
|
try {
|
|
File.SetCreationTime (path, new DateTime (2002, 4, 6, 4, 6, 4));
|
|
DateTime time = File.GetCreationTime (path);
|
|
Assertion.AssertEquals ("test#01", 2002, time.Year);
|
|
Assertion.AssertEquals ("test#02", 4, time.Month);
|
|
Assertion.AssertEquals ("test#03", 6, time.Day);
|
|
Assertion.AssertEquals ("test#04", 4, time.Hour);
|
|
Assertion.AssertEquals ("test#05", 4, time.Second);
|
|
|
|
time = TimeZone.CurrentTimeZone.ToLocalTime (File.GetCreationTimeUtc (path));
|
|
Assertion.AssertEquals ("test#06", 2002, time.Year);
|
|
Assertion.AssertEquals ("test#07", 4, time.Month);
|
|
Assertion.AssertEquals ("test#08", 6, time.Day);
|
|
Assertion.AssertEquals ("test#09", 4, time.Hour);
|
|
Assertion.AssertEquals ("test#10", 4, time.Second);
|
|
|
|
File.SetCreationTimeUtc (path, new DateTime (2002, 4, 6, 4, 6, 4));
|
|
time = File.GetCreationTimeUtc (path);
|
|
Assertion.AssertEquals ("test#11", 2002, time.Year);
|
|
Assertion.AssertEquals ("test#12", 4, time.Month);
|
|
Assertion.AssertEquals ("test#13", 6, time.Day);
|
|
Assertion.AssertEquals ("test#14", 4, time.Hour);
|
|
Assertion.AssertEquals ("test#15", 4, time.Second);
|
|
|
|
time = TimeZone.CurrentTimeZone.ToUniversalTime (File.GetCreationTime (path));
|
|
Assertion.AssertEquals ("test#16", 2002, time.Year);
|
|
Assertion.AssertEquals ("test#17", 4, time.Month);
|
|
Assertion.AssertEquals ("test#18", 6, time.Day);
|
|
Assertion.AssertEquals ("test#19", 4, time.Hour);
|
|
Assertion.AssertEquals ("test#20", 4, time.Second);
|
|
} finally {
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void LastAccessTime ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "lastAccessTime";
|
|
if (File.Exists (path))
|
|
File.Delete (path);
|
|
FileStream stream = null;
|
|
try {
|
|
stream = File.Create (path);
|
|
stream.Close ();
|
|
|
|
File.SetLastAccessTime (path, new DateTime (2002, 4, 6, 4, 6, 4));
|
|
DateTime time = File.GetLastAccessTime (path);
|
|
Assertion.AssertEquals ("test#01", 2002, time.Year);
|
|
Assertion.AssertEquals ("test#02", 4, time.Month);
|
|
Assertion.AssertEquals ("test#03", 6, time.Day);
|
|
Assertion.AssertEquals ("test#04", 4, time.Hour);
|
|
Assertion.AssertEquals ("test#05", 4, time.Second);
|
|
|
|
time = TimeZone.CurrentTimeZone.ToLocalTime (File.GetLastAccessTimeUtc (path));
|
|
Assertion.AssertEquals ("test#06", 2002, time.Year);
|
|
Assertion.AssertEquals ("test#07", 4, time.Month);
|
|
Assertion.AssertEquals ("test#08", 6, time.Day);
|
|
Assertion.AssertEquals ("test#09", 4, time.Hour);
|
|
Assertion.AssertEquals ("test#10", 4, time.Second);
|
|
|
|
File.SetLastAccessTimeUtc (path, new DateTime (2002, 4, 6, 4, 6, 4));
|
|
time = File.GetLastAccessTimeUtc (path);
|
|
Assertion.AssertEquals ("test#11", 2002, time.Year);
|
|
Assertion.AssertEquals ("test#12", 4, time.Month);
|
|
Assertion.AssertEquals ("test#13", 6, time.Day);
|
|
Assertion.AssertEquals ("test#14", 4, time.Hour);
|
|
Assertion.AssertEquals ("test#15", 4, time.Second);
|
|
|
|
time = TimeZone.CurrentTimeZone.ToUniversalTime (File.GetLastAccessTime (path));
|
|
Assertion.AssertEquals ("test#16", 2002, time.Year);
|
|
Assertion.AssertEquals ("test#17", 4, time.Month);
|
|
Assertion.AssertEquals ("test#18", 6, time.Day);
|
|
Assertion.AssertEquals ("test#19", 4, time.Hour);
|
|
Assertion.AssertEquals ("test#20", 4, time.Second);
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void LastWriteTime ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "lastWriteTime";
|
|
if (File.Exists (path))
|
|
File.Delete (path);
|
|
FileStream stream = null;
|
|
try {
|
|
stream = File.Create (path);
|
|
stream.Close ();
|
|
|
|
File.SetLastWriteTime (path, new DateTime (2002, 4, 6, 4, 6, 4));
|
|
DateTime time = File.GetLastWriteTime (path);
|
|
Assertion.AssertEquals ("test#01", 2002, time.Year);
|
|
Assertion.AssertEquals ("test#02", 4, time.Month);
|
|
Assertion.AssertEquals ("test#03", 6, time.Day);
|
|
Assertion.AssertEquals ("test#04", 4, time.Hour);
|
|
Assertion.AssertEquals ("test#05", 4, time.Second);
|
|
|
|
time = TimeZone.CurrentTimeZone.ToLocalTime (File.GetLastWriteTimeUtc (path));
|
|
Assertion.AssertEquals ("test#06", 2002, time.Year);
|
|
Assertion.AssertEquals ("test#07", 4, time.Month);
|
|
Assertion.AssertEquals ("test#08", 6, time.Day);
|
|
Assertion.AssertEquals ("test#09", 4, time.Hour);
|
|
Assertion.AssertEquals ("test#10", 4, time.Second);
|
|
|
|
File.SetLastWriteTimeUtc (path, new DateTime (2002, 4, 6, 4, 6, 4));
|
|
time = File.GetLastWriteTimeUtc (path);
|
|
Assertion.AssertEquals ("test#11", 2002, time.Year);
|
|
Assertion.AssertEquals ("test#12", 4, time.Month);
|
|
Assertion.AssertEquals ("test#13", 6, time.Day);
|
|
Assertion.AssertEquals ("test#14", 4, time.Hour);
|
|
Assertion.AssertEquals ("test#15", 4, time.Second);
|
|
|
|
time = TimeZone.CurrentTimeZone.ToUniversalTime (File.GetLastWriteTime (path));
|
|
Assertion.AssertEquals ("test#16", 2002, time.Year);
|
|
Assertion.AssertEquals ("test#17", 4, time.Month);
|
|
Assertion.AssertEquals ("test#18", 6, time.Day);
|
|
Assertion.AssertEquals ("test#19", 4, time.Hour);
|
|
Assertion.AssertEquals ("test#20", 4, time.Second);
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void GetCreationTimeException1 ()
|
|
{
|
|
File.GetCreationTime (null as string);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetCreationTimeException2 ()
|
|
{
|
|
File.GetCreationTime ("");
|
|
}
|
|
|
|
[Test]
|
|
#if !NET_2_0
|
|
[ExpectedException(typeof(IOException))]
|
|
#endif
|
|
public void GetCreationTime_NonExistingPath ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "GetCreationTimeException3";
|
|
DeleteFile (path);
|
|
DateTime time = File.GetCreationTime (path);
|
|
|
|
#if NET_2_0
|
|
DateTime expectedTime = (new DateTime (1601, 1, 1)).ToLocalTime ();
|
|
Assertion.AssertEquals ("#1", expectedTime.Year, time.Year);
|
|
Assertion.AssertEquals ("#2", expectedTime.Month, time.Month);
|
|
Assertion.AssertEquals ("#3", expectedTime.Day, time.Day);
|
|
Assertion.AssertEquals ("#4", expectedTime.Hour, time.Hour);
|
|
Assertion.AssertEquals ("#5", expectedTime.Second, time.Second);
|
|
Assertion.AssertEquals ("#6", expectedTime.Millisecond, time.Millisecond);
|
|
#endif
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetCreationTimeException4 ()
|
|
{
|
|
File.GetCreationTime (" ");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetCreationTimeException5 ()
|
|
{
|
|
File.GetCreationTime (Path.InvalidPathChars [0].ToString ());
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void GetCreationTimeUtcException1 ()
|
|
{
|
|
File.GetCreationTimeUtc (null as string);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetCreationTimeUtcException2 ()
|
|
{
|
|
File.GetCreationTimeUtc ("");
|
|
}
|
|
|
|
[Test]
|
|
#if !NET_2_0
|
|
[ExpectedException (typeof (IOException))]
|
|
#endif
|
|
public void GetCreationTimeUtc_NonExistingPath ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "GetCreationTimeUtcException3";
|
|
DeleteFile (path);
|
|
DateTime time = File.GetCreationTimeUtc (path);
|
|
|
|
#if NET_2_0
|
|
Assertion.AssertEquals ("#1", 1601, time.Year);
|
|
Assertion.AssertEquals ("#2", 1, time.Month);
|
|
Assertion.AssertEquals ("#3", 1, time.Day);
|
|
Assertion.AssertEquals ("#4", 0, time.Hour);
|
|
Assertion.AssertEquals ("#5", 0, time.Second);
|
|
Assertion.AssertEquals ("#6", 0, time.Millisecond);
|
|
#endif
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetCreationTimeUtcException4 ()
|
|
{
|
|
File.GetCreationTimeUtc (" ");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetCreationTimeUtcException5 ()
|
|
{
|
|
File.GetCreationTime (Path.InvalidPathChars [0].ToString ());
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void GetLastAccessTimeException1 ()
|
|
{
|
|
File.GetLastAccessTime (null as string);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetLastAccessTimeException2 ()
|
|
{
|
|
File.GetLastAccessTime ("");
|
|
}
|
|
|
|
[Test]
|
|
#if !NET_2_0
|
|
[ExpectedException (typeof (IOException))]
|
|
#endif
|
|
public void GetLastAccessTime_NonExistingPath ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "GetLastAccessTimeException3";
|
|
DeleteFile (path);
|
|
DateTime time = File.GetLastAccessTime (path);
|
|
|
|
#if NET_2_0
|
|
DateTime expectedTime = (new DateTime (1601, 1, 1)).ToLocalTime ();
|
|
Assertion.AssertEquals ("#1", expectedTime.Year, time.Year);
|
|
Assertion.AssertEquals ("#2", expectedTime.Month, time.Month);
|
|
Assertion.AssertEquals ("#3", expectedTime.Day, time.Day);
|
|
Assertion.AssertEquals ("#4", expectedTime.Hour, time.Hour);
|
|
Assertion.AssertEquals ("#5", expectedTime.Second, time.Second);
|
|
Assertion.AssertEquals ("#6", expectedTime.Millisecond, time.Millisecond);
|
|
#endif
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetLastAccessTimeException4 ()
|
|
{
|
|
File.GetLastAccessTime (" ");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetLastAccessTimeException5 ()
|
|
{
|
|
File.GetLastAccessTime (Path.InvalidPathChars [0].ToString ());
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void GetLastAccessTimeUtcException1 ()
|
|
{
|
|
File.GetLastAccessTimeUtc (null as string);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetLastAccessTimeUtcException2 ()
|
|
{
|
|
File.GetLastAccessTimeUtc ("");
|
|
}
|
|
|
|
[Test]
|
|
#if !NET_2_0
|
|
[ExpectedException (typeof (IOException))]
|
|
#endif
|
|
public void GetLastAccessTimeUtc_NonExistingPath ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "GetLastAccessTimeUtcException3";
|
|
DeleteFile (path);
|
|
DateTime time = File.GetLastAccessTimeUtc (path);
|
|
|
|
#if NET_2_0
|
|
Assertion.AssertEquals ("#1", 1601, time.Year);
|
|
Assertion.AssertEquals ("#2", 1, time.Month);
|
|
Assertion.AssertEquals ("#3", 1, time.Day);
|
|
Assertion.AssertEquals ("#4", 0, time.Hour);
|
|
Assertion.AssertEquals ("#5", 0, time.Second);
|
|
Assertion.AssertEquals ("#6", 0, time.Millisecond);
|
|
#endif
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetLastAccessTimeUtcException4 ()
|
|
{
|
|
File.GetLastAccessTimeUtc (" ");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetLastAccessTimeUtcException5 ()
|
|
{
|
|
File.GetLastAccessTimeUtc (Path.InvalidPathChars [0].ToString ());
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void GetLastWriteTimeException1 ()
|
|
{
|
|
File.GetLastWriteTime (null as string);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetLastWriteTimeException2 ()
|
|
{
|
|
File.GetLastWriteTime ("");
|
|
}
|
|
|
|
[Test]
|
|
#if !NET_2_0
|
|
[ExpectedException (typeof (IOException))]
|
|
#endif
|
|
public void GetLastWriteTime_NonExistingPath ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "GetLastAccessTimeUtcException3";
|
|
DeleteFile (path);
|
|
DateTime time = File.GetLastWriteTime (path);
|
|
|
|
#if NET_2_0
|
|
DateTime expectedTime = (new DateTime (1601, 1, 1)).ToLocalTime ();
|
|
Assertion.AssertEquals ("#1", expectedTime.Year, time.Year);
|
|
Assertion.AssertEquals ("#2", expectedTime.Month, time.Month);
|
|
Assertion.AssertEquals ("#3", expectedTime.Day, time.Day);
|
|
Assertion.AssertEquals ("#4", expectedTime.Hour, time.Hour);
|
|
Assertion.AssertEquals ("#5", expectedTime.Second, time.Second);
|
|
Assertion.AssertEquals ("#6", expectedTime.Millisecond, time.Millisecond);
|
|
#endif
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetLastWriteTimeException4 ()
|
|
{
|
|
File.GetLastWriteTime (" ");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetLastWriteTimeException5 ()
|
|
{
|
|
File.GetLastWriteTime (Path.InvalidPathChars [0].ToString ());
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void GetLastWriteTimeUtcException1 ()
|
|
{
|
|
File.GetLastWriteTimeUtc (null as string);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetLastWriteTimeUtcException2 ()
|
|
{
|
|
File.GetLastWriteTimeUtc ("");
|
|
}
|
|
|
|
[Test]
|
|
#if !NET_2_0
|
|
[ExpectedException (typeof (IOException))]
|
|
#endif
|
|
public void GetLastWriteTimeUtc_NonExistingPath ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "GetLastWriteTimeUtcException3";
|
|
DeleteFile (path);
|
|
DateTime time = File.GetLastWriteTimeUtc (path);
|
|
|
|
#if NET_2_0
|
|
Assertion.AssertEquals ("#1", 1601, time.Year);
|
|
Assertion.AssertEquals ("#2", 1, time.Month);
|
|
Assertion.AssertEquals ("#3", 1, time.Day);
|
|
Assertion.AssertEquals ("#4", 0, time.Hour);
|
|
Assertion.AssertEquals ("#5", 0, time.Second);
|
|
Assertion.AssertEquals ("#6", 0, time.Millisecond);
|
|
#endif
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetLastWriteTimeUtcException4 ()
|
|
{
|
|
File.GetLastWriteTimeUtc (" ");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void GetLastWriteTimeUtcException5 ()
|
|
{
|
|
File.GetLastWriteTimeUtc (Path.InvalidPathChars [0].ToString ());
|
|
}
|
|
|
|
[Test]
|
|
public void FileStreamClose ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "FileStreamClose";
|
|
FileStream stream = null;
|
|
try {
|
|
stream = File.Create (path);
|
|
stream.Close ();
|
|
File.Delete (path);
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
// SetCreationTime and SetCreationTimeUtc exceptions
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentNullException))]
|
|
public void SetCreationTimeArgumentNullException1 ()
|
|
{
|
|
File.SetCreationTime (null as string, new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void SetCreationTimeArgumenException1 ()
|
|
{
|
|
File.SetCreationTime ("", new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void SetCreationTimeArgumenException2 ()
|
|
{
|
|
File.SetCreationTime (" ", new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
// On Unix there are no invalid path chars.
|
|
public void SetCreationTimeArgumenException3 ()
|
|
{
|
|
if (Path.InvalidPathChars.Length > 1) {
|
|
bool pass = false;
|
|
try {
|
|
File.SetCreationTime (Path.InvalidPathChars [1].ToString (), new DateTime (2000, 12, 12, 11, 59, 59));
|
|
} catch (ArgumentException) {
|
|
pass = true;
|
|
}
|
|
|
|
Assertion.Assert ("#01", pass);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (FileNotFoundException))]
|
|
public void SetCreationTimeFileNotFoundException1 ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "SetCreationTimeFileNotFoundException1";
|
|
DeleteFile (path);
|
|
|
|
File.SetCreationTime (path, new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
// [Test]
|
|
// [ExpectedException(typeof (ArgumentOutOfRangeException))]
|
|
// public void SetCreationTimeArgumentOutOfRangeException1 ()
|
|
// {
|
|
// string path = TempFolder + Path.DirectorySeparatorChar + "SetCreationTimeArgumentOutOfRangeException1";
|
|
// FileStream stream = null;
|
|
// DeleteFile (path);
|
|
// try {
|
|
// stream = File.Create (path);
|
|
// stream.Close ();
|
|
// File.SetCreationTime (path, new DateTime (1000, 12, 12, 11, 59, 59));
|
|
// } finally {
|
|
// if (stream != null)
|
|
// stream.Close ();
|
|
// DeleteFile (path);
|
|
// }
|
|
// }
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (IOException))]
|
|
public void SetCreationTimeIOException1 ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "CreationTimeIOException1";
|
|
DeleteFile (path);
|
|
FileStream stream = null;
|
|
try {
|
|
stream = File.Create (path);
|
|
File.SetCreationTime (path, new DateTime (1000, 12, 12, 11, 59, 59));
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentNullException))]
|
|
public void SetCreationTimeUtcArgumentNullException1 ()
|
|
{
|
|
File.SetCreationTimeUtc (null as string, new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void SetCreationTimeUtcArgumenException1 ()
|
|
{
|
|
File.SetCreationTimeUtc ("", new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void SetCreationTimeUtcArgumenException2 ()
|
|
{
|
|
File.SetCreationTimeUtc (" ", new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
// On Unix there are no invalid path chars.
|
|
public void SetCreationTimeUtcArgumentException3 ()
|
|
{
|
|
if (Path.InvalidPathChars.Length > 1) {
|
|
bool pass = false;
|
|
try {
|
|
File.SetCreationTimeUtc (Path.InvalidPathChars [1].ToString (), new DateTime (2000, 12, 12, 11, 59, 59));
|
|
} catch (ArgumentException) {
|
|
pass = true;
|
|
}
|
|
|
|
Assertion.Assert ("#01", pass);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (FileNotFoundException))]
|
|
public void SetCreationTimeUtcFileNotFoundException1 ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "SetCreationTimeUtcFileNotFoundException1";
|
|
DeleteFile (path);
|
|
|
|
File.SetCreationTimeUtc (path, new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
// [Test]
|
|
// [ExpectedException(typeof (ArgumentOutOfRangeException))]
|
|
// public void SetCreationTimeUtcArgumentOutOfRangeException1 ()
|
|
// {
|
|
// string path = TempFolder + Path.DirectorySeparatorChar + "SetCreationTimeUtcArgumentOutOfRangeException1";
|
|
// DeleteFile (path);
|
|
// FileStream stream = null;
|
|
// try {
|
|
// stream = File.Create (path);
|
|
// stream.Close ();
|
|
// File.SetCreationTimeUtc (path, new DateTime (1000, 12, 12, 11, 59, 59));
|
|
// } finally {
|
|
// if (stream != null)
|
|
// stream.Close();
|
|
// DeleteFile (path);
|
|
// }
|
|
// }
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (IOException))]
|
|
public void SetCreationTimeUtcIOException1 ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "SetCreationTimeUtcIOException1";
|
|
DeleteFile (path);
|
|
FileStream stream = null;
|
|
try {
|
|
stream = File.Create (path);
|
|
File.SetCreationTimeUtc (path, new DateTime (1000, 12, 12, 11, 59, 59));
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
// SetLastAccessTime and SetLastAccessTimeUtc exceptions
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentNullException))]
|
|
public void SetLastAccessTimeArgumentNullException1 ()
|
|
{
|
|
File.SetLastAccessTime (null as string, new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void SetLastAccessTimeArgumenException1 ()
|
|
{
|
|
File.SetLastAccessTime ("", new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void SetLastAccessTimeArgumenException2 ()
|
|
{
|
|
File.SetLastAccessTime (" ", new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
// On Unix there are no invalid path chars.
|
|
public void SetLastAccessTimeArgumenException3 ()
|
|
{
|
|
if (Path.InvalidPathChars.Length > 1) {
|
|
bool pass = false;
|
|
try {
|
|
File.SetLastAccessTime (Path.InvalidPathChars [1].ToString (), new DateTime (2000, 12, 12, 11, 59, 59));
|
|
} catch (ArgumentException) {
|
|
pass = true;
|
|
}
|
|
|
|
Assertion.Assert ("#01", pass);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (FileNotFoundException))]
|
|
public void SetLastAccessTimeFileNotFoundException1 ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "SetLastAccessTimeFileNotFoundException1";
|
|
DeleteFile (path);
|
|
|
|
File.SetLastAccessTime (path, new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
// [Test]
|
|
// [ExpectedException(typeof (ArgumentOutOfRangeException))]
|
|
// public void SetLastAccessTimeArgumentOutOfRangeException1 ()
|
|
// {
|
|
// string path = TempFolder + Path.DirectorySeparatorChar + "SetLastTimeArgumentOutOfRangeException1";
|
|
// DeleteFile (path);
|
|
// FileStream stream = null;
|
|
// try {
|
|
// stream = File.Create (path);
|
|
// stream.Close ();
|
|
// File.SetLastAccessTime (path, new DateTime (1000, 12, 12, 11, 59, 59));
|
|
// } finally {
|
|
// if (stream != null)
|
|
// stream.Close ();
|
|
// DeleteFile (path);
|
|
// }
|
|
// }
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (IOException))]
|
|
public void SetLastAccessTimeIOException1 ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "LastAccessIOException1";
|
|
DeleteFile (path);
|
|
FileStream stream = null;
|
|
try {
|
|
stream = File.Create (path);
|
|
File.SetLastAccessTime (path, new DateTime (1000, 12, 12, 11, 59, 59));
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentNullException))]
|
|
public void SetLastAccessTimeUtcArgumentNullException1 ()
|
|
{
|
|
File.SetLastAccessTimeUtc (null as string, new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void SetCLastAccessTimeUtcArgumenException1 ()
|
|
{
|
|
File.SetLastAccessTimeUtc ("", new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void SetLastAccessTimeUtcArgumenException2 ()
|
|
{
|
|
File.SetLastAccessTimeUtc (" ", new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
// On Unix there are no invalid path chars.
|
|
public void SetLastAccessTimeUtcArgumenException3 ()
|
|
{
|
|
if (Path.InvalidPathChars.Length > 1) {
|
|
bool pass = false;
|
|
try {
|
|
File.SetLastAccessTimeUtc (Path.InvalidPathChars [1].ToString (), new DateTime (2000, 12, 12, 11, 59, 59));
|
|
} catch (ArgumentException) {
|
|
pass = true;
|
|
}
|
|
|
|
Assertion.Assert ("#01", pass);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (FileNotFoundException))]
|
|
public void SetLastAccessTimeUtcFileNotFoundException1 ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "SetLastAccessTimeUtcFileNotFoundException1";
|
|
DeleteFile (path);
|
|
|
|
File.SetLastAccessTimeUtc (path, new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
// [Test]
|
|
// [ExpectedException(typeof (ArgumentOutOfRangeException))]
|
|
// public void SetLastAccessTimeUtcArgumentOutOfRangeException1 ()
|
|
// {
|
|
// string path = TempFolder + Path.DirectorySeparatorChar + "SetLastAccessTimeUtcArgumentOutOfRangeException1";
|
|
// DeleteFile (path);
|
|
// FileStream stream = null;
|
|
// try {
|
|
// stream = File.Create (path);
|
|
// stream.Close ();
|
|
// File.SetLastAccessTimeUtc (path, new DateTime (1000, 12, 12, 11, 59, 59));
|
|
// } finally {
|
|
// if (stream != null)
|
|
// stream.Close ();
|
|
// DeleteFile (path);
|
|
// }
|
|
// }
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (IOException))]
|
|
public void SetLastAccessTimeUtcIOException1 ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "SetLastAccessTimeUtcIOException1";
|
|
DeleteFile (path);
|
|
FileStream stream = null;
|
|
try {
|
|
stream = File.Create (path);
|
|
File.SetLastAccessTimeUtc (path, new DateTime (1000, 12, 12, 11, 59, 59));
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
// SetLastWriteTime and SetLastWriteTimeUtc exceptions
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentNullException))]
|
|
public void SetLastWriteTimeArgumentNullException1 ()
|
|
{
|
|
File.SetLastWriteTime (null as string, new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void SetLastWriteTimeArgumenException1 ()
|
|
{
|
|
File.SetLastWriteTime ("", new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void SetLastWriteTimeArgumenException2 ()
|
|
{
|
|
File.SetLastWriteTime (" ", new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
// On Unix there are no invalid path chars.
|
|
public void SetLastWriteTimeArgumenException3 ()
|
|
{
|
|
if (Path.InvalidPathChars.Length > 1) {
|
|
bool pass = false;
|
|
try {
|
|
File.SetLastWriteTime (Path.InvalidPathChars [1].ToString (), new DateTime (2000, 12, 12, 11, 59, 59));
|
|
} catch (ArgumentException) {
|
|
pass = true;
|
|
}
|
|
|
|
Assertion.Assert ("#01", pass);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (FileNotFoundException))]
|
|
public void SetLastWriteTimeFileNotFoundException1 ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "SetLastWriteTimeFileNotFoundException1";
|
|
DeleteFile (path);
|
|
|
|
File.SetLastWriteTime (path, new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
// [Test]
|
|
// [ExpectedException(typeof (ArgumentOutOfRangeException))]
|
|
// public void SetLastWriteTimeArgumentOutOfRangeException1 ()
|
|
// {
|
|
// string path = TempFolder + Path.DirectorySeparatorChar + "SetLastWriteTimeArgumentOutOfRangeException1";
|
|
// DeleteFile (path);
|
|
// FileStream stream = null;
|
|
// try {
|
|
// stream = File.Create (path);
|
|
// stream.Close ();
|
|
// File.SetLastWriteTime (path, new DateTime (1000, 12, 12, 11, 59, 59));
|
|
// } finally {
|
|
// if (stream != null)
|
|
// stream.Close ();
|
|
// DeleteFile (path);
|
|
// }
|
|
// }
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (IOException))]
|
|
public void SetLastWriteTimeIOException1 ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "LastWriteTimeIOException1";
|
|
DeleteFile (path);
|
|
FileStream stream = null;
|
|
try {
|
|
stream = File.Create (path);
|
|
File.SetLastWriteTime (path, new DateTime (1000, 12, 12, 11, 59, 59));
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentNullException))]
|
|
public void SetLastWriteTimeUtcArgumentNullException1 ()
|
|
{
|
|
File.SetLastWriteTimeUtc (null as string, new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void SetCLastWriteTimeUtcArgumenException1 ()
|
|
{
|
|
File.SetLastWriteTimeUtc ("", new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (ArgumentException))]
|
|
public void SetLastWriteTimeUtcArgumenException2 ()
|
|
{
|
|
File.SetLastWriteTimeUtc (" ", new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
[Test]
|
|
// On Unix there are no invalid path chars.
|
|
public void SetLastWriteTimeUtcArgumenException3 ()
|
|
{
|
|
if (Path.InvalidPathChars.Length > 1) {
|
|
bool pass = false;
|
|
try {
|
|
File.SetLastWriteTimeUtc (Path.InvalidPathChars [1].ToString (), new DateTime (2000, 12, 12, 11, 59, 59));
|
|
} catch (ArgumentException) {
|
|
pass = true;
|
|
}
|
|
|
|
Assertion.Assert ("#01", pass);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof (FileNotFoundException))]
|
|
public void SetLastWriteTimeUtcFileNotFoundException1 ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "SetLastWriteTimeUtcFileNotFoundException1";
|
|
DeleteFile (path);
|
|
|
|
File.SetLastAccessTimeUtc (path, new DateTime (2000, 12, 12, 11, 59, 59));
|
|
}
|
|
|
|
// [Test]
|
|
// [ExpectedException(typeof (ArgumentOutOfRangeException))]
|
|
// public void SetLastWriteTimeUtcArgumentOutOfRangeException1 ()
|
|
// {
|
|
// string path = TempFolder + Path.DirectorySeparatorChar + "SetLastWriteTimeUtcArgumentOutOfRangeException1";
|
|
// DeleteFile (path);
|
|
// FileStream stream = null;
|
|
// try {
|
|
// stream = File.Create (path);
|
|
// stream.Close ();
|
|
// File.SetLastWriteTimeUtc (path, new DateTime (1000, 12, 12, 11, 59, 59));
|
|
// } finally {
|
|
// if (stream != null)
|
|
// stream.Close ();
|
|
// DeleteFile (path);
|
|
// }
|
|
// }
|
|
//
|
|
[Test]
|
|
[ExpectedException(typeof (IOException))]
|
|
public void SetLastWriteTimeUtcIOException1 ()
|
|
{
|
|
string path = TempFolder + Path.DirectorySeparatorChar + "SetLastWriteTimeUtcIOException1";
|
|
DeleteFile (path);
|
|
FileStream stream = null;
|
|
try {
|
|
stream = File.Create (path);
|
|
File.SetLastAccessTimeUtc (path, new DateTime (1000, 12, 12, 11, 59, 59));
|
|
} finally {
|
|
if (stream != null)
|
|
stream.Close ();
|
|
DeleteFile (path);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void OpenAppend ()
|
|
{
|
|
string fn = Path.GetTempFileName ();
|
|
using (FileStream s = File.Open (fn, FileMode.Append))
|
|
;
|
|
|
|
DeleteFile (fn);
|
|
}
|
|
|
|
#if NET_2_0
|
|
void TestRWAT (string s)
|
|
{
|
|
string f = Path.GetTempFileName ();
|
|
try {
|
|
File.WriteAllText (f, s);
|
|
string r = File.ReadAllText (f);
|
|
AssertEquals (r, s);
|
|
} finally {
|
|
DeleteFile (f);
|
|
}
|
|
}
|
|
[Test]
|
|
public void ReadWriteAllText ()
|
|
{
|
|
// The MSDN docs said something about
|
|
// not including a final new line. it looks
|
|
// like that was not true. I'm not sure what
|
|
// that was talking about
|
|
TestRWAT ("");
|
|
TestRWAT ("\r");
|
|
TestRWAT ("\n");
|
|
TestRWAT ("\r\n");
|
|
TestRWAT ("a\r");
|
|
TestRWAT ("a\n");
|
|
TestRWAT ("a\r\n");
|
|
TestRWAT ("a\ra");
|
|
TestRWAT ("a\na");
|
|
TestRWAT ("a\r\na");
|
|
TestRWAT ("a");
|
|
TestRWAT ("\r\r");
|
|
TestRWAT ("\n\n");
|
|
TestRWAT ("\r\n\r\n");
|
|
}
|
|
#endif
|
|
|
|
private void DeleteFile (string path)
|
|
{
|
|
if (File.Exists (path))
|
|
File.Delete (path);
|
|
}
|
|
}
|
|
}
|