// (c) 2003 Ximian, Inc. (http://www.ximian.com)
//
-
using NUnit.Framework;
using System;
using System.IO;
namespace MonoTests.System.IO
{
[TestFixture]
- public class FileStreamTest : Assertion
- {
+ public class FileStreamTest
+ {
string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");
+ static readonly char DSC = Path.DirectorySeparatorChar;
[TearDown]
- public void TearDown()
+ public void TearDown ()
{
if (Directory.Exists (TempFolder))
Directory.Delete (TempFolder, true);
}
[SetUp]
- public void SetUp ()
+ public void SetUp ()
{
if (Directory.Exists (TempFolder))
Directory.Delete (TempFolder, true);
Directory.CreateDirectory (TempFolder);
- }
+ }
- public void TestCtr ()
- {
- string path = TempFolder + "/testfilestream.tmp.1";
+ public void TestCtr ()
+ {
+ string path = TempFolder + DSC + "testfilestream.tmp.1";
DeleteFile (path);
FileStream stream = null;
try {
if (stream != null)
stream.Close ();
- DeleteFile (path);
+ DeleteFile (path);
}
- }
+ }
[Test]
[ExpectedException (typeof (ArgumentException))]
- public void CtorArgumentException1 ()
+ public void CtorArgumentException1 ()
{
FileStream stream;
- stream = new FileStream ("", FileMode.Create);
+ stream = new FileStream ("", FileMode.Create);
stream.Close ();
- }
+ }
[Test]
[ExpectedException (typeof (ArgumentNullException))]
}
[Test]
- [ExpectedException (typeof (FileNotFoundException))]
- public void CtorFileNotFoundException1 ()
+ public void CtorFileNotFoundException_Mode_Open ()
{
- string path = TempFolder + "/thisfileshouldnotexists.test";
+ // absolute path
+ string path = TempFolder + DSC + "thisfileshouldnotexists.test";
DeleteFile (path);
FileStream stream = null;
- try {
- stream = new FileStream (TempFolder + "/thisfileshouldnotexists.test", FileMode.Open);
- } finally {
+ try {
+ stream = new FileStream (TempFolder + DSC + "thisfileshouldnotexists.test", FileMode.Open);
+ Assert.Fail ("#A1");
+ } catch (FileNotFoundException ex) {
+ Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#A2");
+ Assert.AreEqual (path, ex.FileName, "#A3");
+ Assert.IsNull (ex.InnerException, "#A4");
+ Assert.IsNotNull (ex.Message, "#A5");
+ Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#A6");
+ } finally {
+ if (stream != null) {
+ stream.Close ();
+ stream = null;
+ }
+ DeleteFile (path);
+ }
+
+ // relative path
+ string orignalCurrentDir = Directory.GetCurrentDirectory ();
+ Directory.SetCurrentDirectory (TempFolder);
+ try {
+ stream = new FileStream ("thisfileshouldnotexists.test", FileMode.Open);
+ Assert.Fail ("#B1");
+ } catch (FileNotFoundException ex) {
+ Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#B2");
+ Assert.AreEqual (path, ex.FileName, "#B3");
+ Assert.IsNull (ex.InnerException, "#B4");
+ Assert.IsNotNull (ex.Message, "#B5");
+ Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#B6");
+ } finally {
+ // restore original current directory
+ Directory.SetCurrentDirectory (orignalCurrentDir);
if (stream != null)
stream.Close ();
DeleteFile (path);
- }
- }
+ }
+ }
[Test]
- [ExpectedException (typeof (FileNotFoundException))]
- public void CtorFileNotFoundException2 ()
+ public void CtorFileNotFoundException_Mode_Truncate ()
{
- string path = TempFolder + "/thisfileshouldNOTexists.test";
+ // absolute path
+ string path = TempFolder + DSC + "thisfileshouldNOTexists.test";
DeleteFile (path);
FileStream stream = null;
+ try {
+ stream = new FileStream (path, FileMode.Truncate);
+ Assert.Fail ("#A1");
+ } catch (FileNotFoundException ex) {
+ Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#A2");
+ Assert.AreEqual (path, ex.FileName, "#A3");
+ Assert.IsNull (ex.InnerException, "#A4");
+ Assert.IsNotNull (ex.Message, "#A5");
+ Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#A6");
+ } finally {
+ if (stream != null) {
+ stream.Close ();
+ stream = null;
+ }
+ DeleteFile (path);
+ }
- try {
- stream = new FileStream (TempFolder + "/thisfileshouldNOTexists.test", FileMode.Truncate);
- } finally {
+ // relative path
+ string orignalCurrentDir = Directory.GetCurrentDirectory ();
+ Directory.SetCurrentDirectory (TempFolder);
+ try {
+ stream = new FileStream ("thisfileshouldNOTexists.test", FileMode.Truncate);
+ Assert.Fail ("#B1");
+ } catch (FileNotFoundException ex) {
+ Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#B2");
+ Assert.AreEqual (path, ex.FileName, "#B3");
+ Assert.IsNull (ex.InnerException, "#B4");
+ Assert.IsNotNull (ex.Message, "#B5");
+ Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#B6");
+ } finally {
+ // restore original current directory
+ Directory.SetCurrentDirectory (orignalCurrentDir);
if (stream != null)
stream.Close ();
-
DeleteFile (path);
- }
- }
+ }
+ }
[Test]
- [ExpectedException (typeof (IOException))]
public void CtorIOException1 ()
{
- string path = TempFolder + "/thisfileshouldexists.test";
+ // absolute path
+ string path = TempFolder + DSC + "thisfileshouldexists.test";
FileStream stream = null;
DeleteFile (path);
- try {
- stream = new FileStream (path, FileMode.CreateNew);
- stream.Close ();
- stream = null;
- stream = new FileStream (path, FileMode.CreateNew);
- } finally {
-
- if (stream != null)
+ try {
+ stream = new FileStream (path, FileMode.CreateNew);
+ stream.Close ();
+ stream = null;
+ stream = new FileStream (path, FileMode.CreateNew);
+ Assert.Fail ("#A1");
+ } catch (IOException ex) {
+ Assert.AreEqual (typeof (IOException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.IsNotNull (ex.Message, "#A4");
+ Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#A5");
+ } finally {
+ if (stream != null) {
stream.Close ();
+ stream = null;
+ }
DeleteFile (path);
- }
+ }
+ // relative path
+ string orignalCurrentDir = Directory.GetCurrentDirectory ();
+ Directory.SetCurrentDirectory (TempFolder);
+ try {
+ stream = new FileStream ("thisfileshouldexists.test", FileMode.CreateNew);
+ stream.Close ();
+ stream = null;
+ stream = new FileStream ("thisfileshouldexists.test", FileMode.CreateNew);
+ Assert.Fail ("#B1");
+ } catch (IOException ex) {
+ Assert.AreEqual (typeof (IOException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+ Assert.IsNotNull (ex.Message, "#B4");
+ Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#B5");
+ } finally {
+ // restore original current directory
+ Directory.SetCurrentDirectory (orignalCurrentDir);
+ if (stream != null)
+ stream.Close ();
+ DeleteFile (path);
+ }
}
[Test]
FileStream stream = null;
string path = TempFolder + Path.DirectorySeparatorChar + "temp";
DeleteFile (path);
- try {
- stream = new FileStream (path, FileMode.Append | FileMode.CreateNew);
- } finally {
+ try {
+ stream = new FileStream (path, FileMode.Append | FileMode.CreateNew);
+ } finally {
if (stream != null)
stream.Close ();
DeleteFile (path);
- }
- }
+ }
+ }
[Test]
[ExpectedException (typeof (ArgumentOutOfRangeException))]
FileStream stream = null;
string path = TempFolder + Path.DirectorySeparatorChar + "temp";
DeleteFile (path);
- try {
- stream = new FileStream ("test.test.test", FileMode.Append | FileMode.Open);
- } finally {
+ try {
+ stream = new FileStream ("test.test.test", FileMode.Append | FileMode.Open);
+ } finally {
if (stream != null)
stream.Close ();
DeleteFile (path);
- }
+ }
}
- [Test]
- [ExpectedException (typeof (DirectoryNotFoundException))]
- public void CtorDirectoryNotFoundException ()
+ private void CtorDirectoryNotFoundException (FileMode mode)
{
- string path = TempFolder + "/thisDirectoryShouldNotExists";
+ string path = TempFolder + DSC + "thisDirectoryShouldNotExists";
if (Directory.Exists (path))
Directory.Delete (path, true);
- FileStream stream = null;
- try {
- stream = new FileStream (path + "/eitherthisfile.test", FileMode.CreateNew);
- } finally {
+ FileStream stream = null;
+ try {
+ stream = new FileStream (path + DSC + "eitherthisfile.test", mode);
+ } finally {
if (stream != null)
stream.Close ();
if (Directory.Exists (path))
Directory.Delete (path, true);
- }
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (DirectoryNotFoundException))]
+ public void CtorDirectoryNotFoundException_CreateNew ()
+ {
+ CtorDirectoryNotFoundException (FileMode.CreateNew);
+ }
+
+ [Test]
+ [ExpectedException (typeof (DirectoryNotFoundException))]
+ public void CtorDirectoryNotFoundException_Create ()
+ {
+ CtorDirectoryNotFoundException (FileMode.Create);
+ }
+
+ [Test]
+ [ExpectedException (typeof (DirectoryNotFoundException))]
+ public void CtorDirectoryNotFoundException_Open ()
+ {
+ CtorDirectoryNotFoundException (FileMode.Open);
+ }
+
+ [Test]
+ [ExpectedException (typeof (DirectoryNotFoundException))]
+ public void CtorDirectoryNotFoundException_OpenOrCreate ()
+ {
+ CtorDirectoryNotFoundException (FileMode.OpenOrCreate);
+ }
+
+ [Test]
+ [ExpectedException (typeof (DirectoryNotFoundException))]
+ public void CtorDirectoryNotFoundException_Truncate ()
+ {
+ CtorDirectoryNotFoundException (FileMode.Truncate);
+ }
+
+ [Test]
+ [ExpectedException (typeof (DirectoryNotFoundException))]
+ public void CtorDirectoryNotFoundException_Append ()
+ {
+ CtorDirectoryNotFoundException (FileMode.Append);
+ }
+
+ [Test]
+ public void CtorDirectoryNotFound_RelativePath ()
+ {
+ string orignalCurrentDir = Directory.GetCurrentDirectory ();
+ Directory.SetCurrentDirectory (TempFolder);
+ string relativePath = "DirectoryDoesNotExist" + Path.DirectorySeparatorChar + "file.txt";
+ string fullPath = Path.Combine (TempFolder, relativePath);
+ try {
+ new FileStream (relativePath, FileMode.Open);
+ Assert.Fail ("#A1");
+ } catch (DirectoryNotFoundException ex) {
+ Assert.AreEqual (typeof (DirectoryNotFoundException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.IsNotNull (ex.Message, "#A4");
+ Assert.IsTrue (ex.Message.IndexOf (fullPath) != -1, "#A5");
+ } finally {
+ // restore original current directory
+ Directory.SetCurrentDirectory (orignalCurrentDir);
+ }
}
[Test]
+#if NET_2_0
+ // FileShare.Inheritable is ignored, but file does not exist
+ [ExpectedException (typeof (FileNotFoundException))]
+#else
+ // share: Enum value was out of legal range.
+ // (FileShare.Inheritable is not valid)
[ExpectedException (typeof (ArgumentOutOfRangeException))]
+#endif
public void CtorArgumentOutOfRangeException3 ()
{
- string path = TempFolder + "/CtorArgumentOutOfRangeException1";
+ string path = TempFolder + DSC + "CtorArgumentOutOfRangeException1";
DeleteFile (path);
-
+
FileStream stream = null;
try {
- stream = new FileStream (path, FileMode.CreateNew, FileAccess.Read, FileShare.None | FileShare.Inheritable);
+ stream = new FileStream (path, FileMode.Open, FileAccess.Read, FileShare.Inheritable);
} finally {
if (stream != null)
stream.Close ();
[ExpectedException (typeof (ArgumentOutOfRangeException))]
public void CtorArgumentOutOfRangeException4 ()
{
- string path = TempFolder + "/CtorArgumentOutOfRangeException2";
+ string path = TempFolder + DSC + "CtorArgumentOutOfRangeException4";
+ DeleteFile (path);
+
+ FileStream stream = null;
+ try {
+ stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read, FileShare.ReadWrite, -1);
+ } finally {
+ if (stream != null)
+ stream.Close ();
+ DeleteFile (path);
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void CtorBufferSizeZero ()
+ {
+ // Buffer size can't be zero
+
+ string path = Path.Combine (TempFolder, "CtorBufferSizeZero");
DeleteFile (path);
FileStream stream = null;
try {
- stream = new FileStream (path, FileMode.Truncate, FileAccess.Read, FileShare.ReadWrite, -1);
+ stream = new FileStream (path, FileMode.CreateNew, FileAccess.Write, FileShare.ReadWrite, 0);
} finally {
if (stream != null)
stream.Close ();
DeleteFile (path);
}
- }
-
+ }
+
[Test]
[ExpectedException (typeof (ArgumentException))]
public void CtorArgumentException2 ()
{
- // FileMode.CreateNew && FileAccess.Read
+ // FileMode.CreateNew && FileAccess.Read
string path = TempFolder + Path.DirectorySeparatorChar + "temp";
- FileStream stream = null;
+ FileStream stream = null;
DeleteFile (path);
- try {
- stream = new FileStream (".test.test.test.2", FileMode.CreateNew, FileAccess.Read, FileShare.None | FileShare.Write);
- } finally {
+ try {
+ stream = new FileStream (".test.test.test.2", FileMode.CreateNew, FileAccess.Read, FileShare.None | FileShare.Write);
+ } finally {
if (stream != null)
stream.Close ();
DeleteFile (path);
- }
+ }
}
[Test]
+#if NET_2_0
+ // FileShare.Inheritable is ignored, but file does not exist
+ [ExpectedException (typeof (FileNotFoundException))]
+#else
+ // share: Enum value was out of legal range.
+ // (FileShare.Inheritable is not valid)
[ExpectedException (typeof (ArgumentOutOfRangeException))]
+#endif
public void CtorArgumentOutOfRangeException5 ()
{
string path = TempFolder + Path.DirectorySeparatorChar + "temp";
DeleteFile (path);
FileStream stream = null;
- try {
- stream = new FileStream (path, FileMode.CreateNew, FileAccess.Read, FileShare.Inheritable | FileShare.ReadWrite);
- } finally {
+ try {
+ stream = new FileStream (path, FileMode.Open, FileAccess.Read, FileShare.Inheritable | FileShare.ReadWrite);
+ } finally {
if (stream != null)
stream.Close ();
DeleteFile (path);
- }
- }
+ }
+ }
+
-
[Test]
[ExpectedException (typeof (ArgumentException))]
public void CtorArgumentException3 ()
{
string path = TempFolder + Path.DirectorySeparatorChar + "temp";
- FileStream stream = null;
+ FileStream stream = null;
DeleteFile (path);
-
- try {
- stream = new FileStream (".test.test.test.2", FileMode.Truncate, FileAccess.Read);
- } finally {
+
+ try {
+ stream = new FileStream (".test.test.test.2", FileMode.Truncate, FileAccess.Read);
+ } finally {
if (stream != null)
stream.Close ();
-
+
DeleteFile (path);
- }
+ }
}
[Test]
- [ExpectedException (typeof (IOException))]
- public void CtorIOException2 ()
+ public void ModeAndAccessCombinations ()
{
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
FileStream stream = null;
- try {
- stream = new FileStream (new IntPtr (12), FileAccess.Read);
- } finally {
+
+ // Append / Read
+ try {
+ // Append access can be requested only in write-only mode
+ stream = new FileStream (path, FileMode.Append, FileAccess.Read);
+ Assert.Fail ("#A1");
+ } catch (ArgumentException ex) {
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
+ } finally {
if (stream != null)
stream.Close ();
- }
- }
- [Test]
- [ExpectedException(typeof(IOException))]
- public void CtorIOException ()
- {
- string path = TempFolder + "/CTorIOException.Test";
- FileStream stream = null;
- FileStream stream2 = null;
- DeleteFile (path);
+ DeleteFile (path);
+ }
+ // Append / ReadWrite
try {
- stream = new FileStream (path, FileMode.CreateNew);
-
- // used by an another process
- stream2 = new FileStream (path, FileMode.OpenOrCreate);
+ // Append access can be requested only in write-only mode
+ stream = new FileStream (path, FileMode.Append, FileAccess.ReadWrite);
+ Assert.Fail ("#B1");
+ } catch (ArgumentException ex) {
+ // make sure it is exact this exception, and not a derived type
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
} finally {
if (stream != null)
stream.Close ();
- if (stream2 != null)
- stream2.Close ();
+
DeleteFile (path);
}
- }
-
- [Test]
- public void Write ()
- {
- string path = TempFolder + "/FileStreamTest.Write";
- DeleteFile (path);
+ // Append / Write
+ try {
+ stream = new FileStream (path, FileMode.Append, FileAccess.Write);
+ } finally {
+ if (stream != null)
+ stream.Close ();
- FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite, 8);
+ DeleteFile (path);
+ }
- byte[] outbytes = new byte [] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
- byte[] bytes = new byte [15];
+ // Create / Read
+ try {
+ stream = new FileStream (path, FileMode.Create, FileAccess.Read);
+ Assert.Fail ("#C1");
+ } catch (ArgumentException ex) {
+ // make sure it is exact this exception, and not a derived type
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
+ } finally {
+ if (stream != null)
+ stream.Close ();
- // Check that the data is flushed when we overflow the buffer
- // with a large amount of data
- stream.Write (outbytes, 0, 5);
- stream.Write (outbytes, 5, 10);
- stream.Seek (0, SeekOrigin.Begin);
+ DeleteFile (path);
+ }
- stream.Read (bytes, 0, 15);
- for (int i = 0; i < 15; ++i)
- AssertEquals (i + 1, bytes [i]);
+ // Create / ReadWrite
+ try {
+ stream = new FileStream (path, FileMode.Create, FileAccess.ReadWrite);
+ } finally {
+ if (stream != null)
+ stream.Close ();
- // Check that the data is flushed when we overflow the buffer
- // with a small amount of data
- stream.Write (outbytes, 0, 7);
- stream.Write (outbytes, 7, 7);
- stream.Write (outbytes, 14, 1);
+ DeleteFile (path);
+ }
- stream.Read (bytes, 0, 15);
- stream.Seek (15, SeekOrigin.Begin);
- for (int i = 0; i < 15; ++i)
- AssertEquals (i + 1, bytes [i]);
- stream.Close ();
- }
+ // Create / Write
+ try {
+ stream = new FileStream (path, FileMode.Create, FileAccess.Write);
+ } finally {
+ if (stream != null)
+ stream.Close ();
- [Test]
- public void Length ()
- {
- // Test that the Length property takes into account the data
- // in the buffer
- string path = TempFolder + "/FileStreamTest.Length";
+ DeleteFile (path);
+ }
- DeleteFile (path);
+ // CreateNew / Read
+ try {
+ stream = new FileStream (path, FileMode.CreateNew, FileAccess.Read);
+ Assert.Fail ("#D1");
+ } catch (ArgumentException ex) {
+ // make sure it is exact this exception, and not a derived type
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
+ } finally {
+ if (stream != null)
+ stream.Close ();
- FileStream stream = new FileStream (path, FileMode.CreateNew);
+ DeleteFile (path);
+ }
- byte[] outbytes = new byte [] {1, 2, 3, 4};
+ // CreateNew / ReadWrite
+ try {
+ stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite);
+ } finally {
+ if (stream != null)
+ stream.Close ();
- stream.Write (outbytes, 0, 4);
- AssertEquals (stream.Length, 4);
- stream.Close ();
- }
-
- [Test]
- public void Flush ()
- {
- string path = TempFolder + "/FileStreamTest.Flush";
- FileStream stream = null;
- FileStream stream2 = null;
+ DeleteFile (path);
+ }
- DeleteFile (path);
-
+ // CreateNew / Write
try {
- stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite);
- stream2 = new FileStream (path, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
+ stream = new FileStream (path, FileMode.CreateNew, FileAccess.Write);
+ } finally {
+ if (stream != null)
+ stream.Close ();
- stream.Write (new byte [] {1, 2, 3, 4, 5}, 0, 5);
-
- byte [] bytes = new byte [5];
- stream2.Read (bytes, 0, 5);
-
- AssertEquals ("test#01", 0, bytes [0]);
- AssertEquals ("test#02", 0, bytes [1]);
- AssertEquals ("test#03", 0, bytes [2]);
- AssertEquals ("test#04", 0, bytes [3]);
-
- stream.Flush ();
- stream2.Read (bytes, 0, 5);
- AssertEquals ("test#05", 1, bytes [0]);
- AssertEquals ("test#06", 2, bytes [1]);
- AssertEquals ("test#07", 3, bytes [2]);
- AssertEquals ("test#08", 4, bytes [3]);
+ DeleteFile (path);
+ }
+
+ // Open / Read
+ try {
+ stream = new FileStream (path, FileMode.Open, FileAccess.Read);
+ Assert.Fail ("#E1");
+ } catch (FileNotFoundException ex) {
+ // make sure it is exact this exception, and not a derived type
+ Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#E2");
+ Assert.AreEqual (path, ex.FileName, "#E3");
+ Assert.IsNull (ex.InnerException, "#E4");
+ Assert.IsNotNull (ex.Message, "#E5");
+ Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#E6");
} finally {
if (stream != null)
stream.Close ();
- if (stream2 != null)
- stream2.Close ();
-
+
DeleteFile (path);
}
- }
-
- public void TestDefaultProperties ()
- {
- string path = TempFolder + Path.DirectorySeparatorChar + "testfilestream.tmp.2";
- DeleteFile (path);
- FileStream stream = new FileStream (path, FileMode.Create);
-
- AssertEquals ("test#01", true, stream.CanRead);
- AssertEquals ("test#02", true, stream.CanSeek);
- AssertEquals ("test#03", true, stream.CanWrite);
- AssertEquals ("test#04", false, stream.IsAsync);
- AssertEquals ("test#05", true, stream.Name.EndsWith (path));
- AssertEquals ("test#06", 0, stream.Position);
- AssertEquals ("test#07", "System.IO.FileStream", stream.ToString());
- stream.Close ();
- DeleteFile (path);
-
- stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read);
- AssertEquals ("test#08", true, stream.CanRead);
- AssertEquals ("test#09", true, stream.CanSeek);
- AssertEquals ("test#10", false, stream.CanWrite);
- AssertEquals ("test#11", false, stream.IsAsync);
- AssertEquals ("test#12", true, stream.Name.EndsWith (path));
- AssertEquals ("test#13", 0, stream.Position);
- AssertEquals ("test#14", "System.IO.FileStream", stream.ToString());
- stream.Close ();
-
- stream = new FileStream (path, FileMode.Truncate, FileAccess.Write, FileShare.ReadWrite);
- AssertEquals ("test#15", false, stream.CanRead);
- AssertEquals ("test#16", true, stream.CanSeek);
- AssertEquals ("test#17", true, stream.CanWrite);
- AssertEquals ("test#18", false, stream.IsAsync);
- AssertEquals ("test#19", true, stream.Name.EndsWith ("testfilestream.tmp.2"));
- AssertEquals ("test#20", 0, stream.Position);
- AssertEquals ("test#21", "System.IO.FileStream", stream.ToString());
- stream.Close ();
- DeleteFile (path);
- }
-
- public void TestLock()
- {
- string path = TempFolder + Path.DirectorySeparatorChar + "TestLock";
- DeleteFile (path);
-
- FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite);
-
- stream.Write (new Byte [] {0,1,2,3,4,5,6,7,8,9,10}, 0, 10);
- stream.Close ();
-
- stream = new FileStream (path, FileMode.Open, FileAccess.ReadWrite);
-
- stream.Lock (0, 5);
-
- FileStream stream2 = new FileStream (path , FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-
- byte [] bytes = new byte [5];
- try {
- stream2.Read (bytes, 0, 5);
- Fail ();
- } catch (Exception e) {
-
- // locked
- AssertEquals ("test#01", typeof (IOException), e.GetType ());
- }
-
- stream2.Seek (5, SeekOrigin.Begin);
- stream2.Read (bytes, 0, 5);
-
- AssertEquals ("test#02", 5, bytes [0]);
- AssertEquals ("test#03", 6, bytes [1]);
- AssertEquals ("test#04", 7, bytes [2]);
- AssertEquals ("test#05", 8, bytes [3]);
- AssertEquals ("test#06", 9, bytes [4]);
-
- stream.Unlock (0,5);
- stream2.Seek (0, SeekOrigin.Begin);
- stream2.Read (bytes, 0, 5);
-
- AssertEquals ("test#02", 0, bytes [0]);
- AssertEquals ("test#03", 1, bytes [1]);
- AssertEquals ("test#04", 2, bytes [2]);
- AssertEquals ("test#05", 3, bytes [3]);
- AssertEquals ("test#06", 4, bytes [4]);
-
- stream.Close ();
- stream2.Close ();
-
- DeleteFile (path);
- }
-
- [Test]
- public void Seek ()
- {
- string path = TempFolder + "/FST.Seek.Test";
- DeleteFile (path);
-
- FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite);
- FileStream stream2 = new FileStream (path, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
-
- stream.Write (new byte [] {1, 2, 3, 4, 5, 6, 7, 8, 10}, 0, 9);
- AssertEquals ("test#01", 5, stream2.Seek (5, SeekOrigin.Begin));
- AssertEquals ("test#02", -1, stream2.ReadByte ());
-
- AssertEquals ("test#03", 2, stream2.Seek (-3, SeekOrigin.Current));
- AssertEquals ("test#04", -1, stream2.ReadByte ());
-
- AssertEquals ("test#05", 12, stream.Seek (3, SeekOrigin.Current));
- AssertEquals ("test#06", -1, stream.ReadByte ());
-
- AssertEquals ("test#07", 5, stream.Seek (-7, SeekOrigin.Current));
- AssertEquals ("test#08", 6, stream.ReadByte ());
-
- AssertEquals ("test#09", 5, stream2.Seek (5, SeekOrigin.Begin));
- AssertEquals ("test#10", 6, stream2.ReadByte ());
-
- stream.Close ();
- stream2.Close ();
-
- DeleteFile (path);
- }
-
- public void TestSeek ()
- {
- string path = TempFolder + Path.DirectorySeparatorChar + "TestSeek";
- DeleteFile (path);
-
- FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite);
- stream.Write (new byte[] {1, 2, 3, 4, 5, 6, 7, 8 , 9, 10}, 0, 10);
-
- stream.Seek (5, SeekOrigin.End);
- AssertEquals ("test#01", -1, stream.ReadByte ());
-
- stream.Seek (-5, SeekOrigin.End);
- AssertEquals ("test#02", 6, stream.ReadByte ());
-
- try {
- stream.Seek (-11, SeekOrigin.End);
- Fail ();
- } catch (Exception e) {
- AssertEquals ("test#03", typeof (IOException), e.GetType ());
- }
-
- stream.Seek (19, SeekOrigin.Begin);
- AssertEquals ("test#04", -1, stream.ReadByte ());
-
- stream.Seek (1, SeekOrigin.Begin);
- AssertEquals ("test#05", 2, stream.ReadByte ());
-
- stream.Seek (3, SeekOrigin.Current);
- AssertEquals ("test#06", 6, stream.ReadByte ());
-
- stream.Seek (-2, SeekOrigin.Current);
- AssertEquals ("test#07", 5, stream.ReadByte ());
-
- stream.Flush ();
-
- // Test that seeks work correctly when seeking inside the buffer
- stream.Seek (0, SeekOrigin.Begin);
- stream.WriteByte (0);
- stream.WriteByte (1);
- stream.Seek (0, SeekOrigin.Begin);
- byte[] buf = new byte [1];
- buf [0] = 2;
- stream.Write (buf, 0, 1);
- stream.Write (buf, 0, 1);
- stream.Flush ();
- stream.Seek (0, SeekOrigin.Begin);
- AssertEquals ("test#08", 2, stream.ReadByte ());
- AssertEquals ("test#09", 2, stream.ReadByte ());
-
- stream.Close ();
-
- DeleteFile (path);
- }
-
- public void TestClose ()
- {
- string path = TempFolder + Path.DirectorySeparatorChar + "TestClose";
- DeleteFile (path);
-
- FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite);
+ // Open / ReadWrite
+ try {
+ stream = new FileStream (path, FileMode.Open, FileAccess.ReadWrite);
+ Assert.Fail ("#F1");
+ } catch (FileNotFoundException ex) {
+ // make sure it is exact this exception, and not a derived type
+ Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#F2");
+ Assert.AreEqual (path, ex.FileName, "#F3");
+ Assert.IsNull (ex.InnerException, "#F4");
+ Assert.IsNotNull (ex.Message, "#F5");
+ Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#F6");
+ } finally {
+ if (stream != null)
+ stream.Close ();
- stream.Write (new byte [] {1, 2, 3, 4}, 0, 4);
- stream.ReadByte ();
- stream.Close ();
-
- try {
- stream.ReadByte ();
- Fail ();
- } catch (Exception e) {
- AssertEquals ("test#01", typeof (ObjectDisposedException), e.GetType ());
+ DeleteFile (path);
}
-
- try {
- stream.WriteByte (64);
- Fail ();
- } catch (Exception e) {
- AssertEquals ("test#02", typeof (ObjectDisposedException), e.GetType ());
+
+ // Open / Write
+ try {
+ stream = new FileStream (path, FileMode.Open, FileAccess.Write);
+ Assert.Fail ("#G1");
+ } catch (FileNotFoundException ex) {
+ // make sure it is exact this exception, and not a derived type
+ Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#G2");
+ Assert.AreEqual (path, ex.FileName, "#G3");
+ Assert.IsNull (ex.InnerException, "#G4");
+ Assert.IsNotNull (ex.Message, "#G5");
+ Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#G6");
+ } finally {
+ if (stream != null)
+ stream.Close ();
+
+ DeleteFile (path);
+ }
+
+ // OpenOrCreate / Read
+ try {
+ stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read);
+ } finally {
+ if (stream != null)
+ stream.Close ();
+
+ DeleteFile (path);
+ }
+
+ // OpenOrCreate / ReadWrite
+ try {
+ stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.ReadWrite);
+ } finally {
+ if (stream != null)
+ stream.Close ();
+
+ DeleteFile (path);
+ }
+
+ // OpenOrCreate / Write
+ try {
+ stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write);
+ } finally {
+ if (stream != null)
+ stream.Close ();
+
+ DeleteFile (path);
+ }
+
+ // Truncate / Read
+ try {
+ stream = new FileStream (path, FileMode.Truncate, FileAccess.Read);
+ Assert.Fail ("#H1");
+ } catch (ArgumentException ex) {
+ // make sure it is exact this exception, and not a derived type
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#H2");
+ } finally {
+ if (stream != null)
+ stream.Close ();
+
+ DeleteFile (path);
+ }
+
+ // Truncate / ReadWrite
+ try {
+ stream = new FileStream (path, FileMode.Truncate, FileAccess.ReadWrite);
+ Assert.Fail ("#I1");
+ } catch (FileNotFoundException ex) {
+ // make sure it is exact this exception, and not a derived type
+ Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#I2");
+ Assert.AreEqual (path, ex.FileName, "#I3");
+ Assert.IsNull (ex.InnerException, "#I4");
+ Assert.IsNotNull (ex.Message, "#I5");
+ Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#I6");
+ } finally {
+ if (stream != null)
+ stream.Close ();
+
+ DeleteFile (path);
+ }
+
+ // Truncate / Write
+ try {
+ stream = new FileStream (path, FileMode.Truncate, FileAccess.Write);
+ Assert.Fail ("#J1");
+ } catch (FileNotFoundException ex) {
+ // make sure it is exact this exception, and not a derived type
+ Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#J2");
+ Assert.AreEqual (path, ex.FileName, "#J3");
+ Assert.IsNull (ex.InnerException, "#J4");
+ Assert.IsNotNull (ex.Message, "#J5");
+ Assert.IsTrue (ex.Message.IndexOf (path) != -1, "#J6");
+ } finally {
+ if (stream != null)
+ stream.Close ();
+
+ DeleteFile (path);
}
+ }
+
+#if !TARGET_JVM // No support IntPtr file handles under TARGET_JVM
+ [Test, ExpectedException (typeof (IOException))]
+ public void CtorIOException2 ()
+ {
+ FileStream stream = null;
+ try {
+ stream = new FileStream (new IntPtr (Int32.MaxValue), FileAccess.Read);
+ } finally {
+ if (stream != null)
+ stream.Close ();
+ }
+ }
+#endif // TARGET_JVM
+
+ [Category("TargetJvmNotSupported")] // File sharing not supported for TARGET_JVM
+ [Test, ExpectedException (typeof (IOException))]
+ public void CtorIOException ()
+ {
+ string path = TempFolder + DSC + "CTorIOException.Test";
+ FileStream stream = null;
+ FileStream stream2 = null;
+ DeleteFile (path);
+
+ try {
+ stream = new FileStream (path, FileMode.CreateNew);
+
+ // used by an another process
+ stream2 = new FileStream (path, FileMode.OpenOrCreate);
+ } finally {
+ if (stream != null)
+ stream.Close ();
+ if (stream2 != null)
+ stream2.Close ();
+ DeleteFile (path);
+ }
+ }
+
+ [Test]
+ public void CtorAccess1Read2Read ()
+ {
+ FileStream fs = null;
+ FileStream fs2 = null;
+ string fn = Path.Combine (TempFolder, "temp");
+ try {
+ if (!File.Exists (fn)) {
+ TextWriter tw = File.CreateText (fn);
+ tw.Write ("FOO");
+ tw.Close ();
+ }
+ fs = new FileStream (fn, FileMode.Open, FileAccess.Read);
+ fs2 = new FileStream (fn, FileMode.Open, FileAccess.Read);
+ } finally {
+ if (fs != null)
+ fs.Close ();
+ if (fs2 != null)
+ fs2.Close ();
+ if (File.Exists (fn))
+ File.Delete (fn);
+ }
+ }
+
+ [Test]
+ [Category("TargetJvmNotSupported")] // File sharing not supported for TARGET_JVM
+ [ExpectedException (typeof (IOException))]
+ public void CtorAccess1Read2Write ()
+ {
+ string fn = Path.Combine (TempFolder, "temp");
+ FileStream fs1 = null;
+ FileStream fs2 = null;
+ try {
+ if (!File.Exists (fn)) {
+ using (TextWriter tw = File.CreateText (fn)) {
+ tw.Write ("FOO");
+ }
+ }
+ fs1 = new FileStream (fn, FileMode.Open, FileAccess.Read);
+ fs2 = new FileStream (fn, FileMode.Create, FileAccess.Write);
+ } finally {
+ if (fs1 != null)
+ fs1.Close ();
+ if (fs2 != null)
+ fs2.Close ();
+ if (File.Exists (fn))
+ File.Delete (fn);
+ }
+ }
+
+ [Test]
+ [Category("TargetJvmNotSupported")] // File sharing not supported for TARGET_JVM
+ [ExpectedException (typeof (IOException))]
+ public void CtorAccess1Write2Write ()
+ {
+ string fn = Path.Combine (TempFolder, "temp");
+ FileStream fs1 = null;
+ FileStream fs2 = null;
+ try {
+ if (File.Exists (fn))
+ File.Delete (fn);
+ fs1 = new FileStream (fn, FileMode.Create, FileAccess.Write);
+ fs2 = new FileStream (fn, FileMode.Create, FileAccess.Write);
+ } finally {
+ if (fs1 != null)
+ fs1.Close ();
+ if (fs2 != null)
+ fs2.Close ();
+ if (File.Exists (fn))
+ File.Delete (fn);
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (UnauthorizedAccessException))]
+ public void CtorReadDirectoryAsFile ()
+ {
+ FileStream stream = null;
+ try {
+ stream = new FileStream (TempFolder, FileMode.Open, FileAccess.Read);
+ } finally {
+ if (stream != null)
+ stream.Close ();
+ }
+ }
+
+#if NET_2_0
+ [Test] // bug #79250
+ public void FileShare_Delete ()
+ {
+ string fn = Path.Combine (TempFolder, "temp");
- try {
- stream.Flush ();
- Fail ();
+ using (Stream s = new FileStream (fn, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Delete)) {
+ s.Write (new byte [1] { 0x5 }, 0, 1);
+ File.Delete (fn);
+ }
+
+ using (Stream s = new FileStream (fn, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite | FileShare.Delete)) {
+ s.Write (new byte [1] { 0x5 }, 0, 1);
+ File.Delete (fn);
+ }
+
+ using (Stream s = new FileStream (fn, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Write | FileShare.Delete)) {
+ s.Write (new byte [1] { 0x5 }, 0, 1);
+ File.Delete (fn);
+ }
+
+ using (Stream s = new FileStream (fn, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read | FileShare.Delete)) {
+ s.Write (new byte [1] { 0x5 }, 0, 1);
+ File.Delete (fn);
+ }
+
+ using (Stream s = new FileStream (fn, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Inheritable | FileShare.Delete)) {
+ s.Write (new byte [1] { 0x5 }, 0, 1);
+ File.Delete (fn);
+ }
+ }
+#endif
+
+ [Test]
+ public void Write ()
+ {
+ string path = TempFolder + DSC + "FileStreamTest.Write";
+
+ DeleteFile (path);
+
+ FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite, 8);
+
+ byte[] outbytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
+ byte[] bytes = new byte[15];
+
+ // Check that the data is flushed when we overflow the buffer
+ // with a large amount of data
+ stream.Write (outbytes, 0, 5);
+ stream.Write (outbytes, 5, 10);
+ stream.Seek (0, SeekOrigin.Begin);
+
+ stream.Read (bytes, 0, 15);
+ for (int i = 0; i < 15; ++i)
+ Assert.AreEqual (i + 1, bytes[i], "#1");
+
+ // Check that the data is flushed when we overflow the buffer
+ // with a small amount of data
+ stream.Write (outbytes, 0, 7);
+ stream.Write (outbytes, 7, 7);
+ stream.Write (outbytes, 14, 1);
+
+ stream.Read (bytes, 0, 15);
+ stream.Seek (15, SeekOrigin.Begin);
+ for (int i = 0; i < 15; ++i)
+ Assert.AreEqual (i + 1, bytes[i], "#2");
+ stream.Close ();
+ }
+
+ [Test]
+ public void Length ()
+ {
+ // Test that the Length property takes into account the data
+ // in the buffer
+ string path = TempFolder + DSC + "FileStreamTest.Length";
+
+ DeleteFile (path);
+
+ FileStream stream = new FileStream (path, FileMode.CreateNew);
+
+ byte[] outbytes = new byte[] { 1, 2, 3, 4 };
+
+ stream.Write (outbytes, 0, 4);
+ Assert.AreEqual (4, stream.Length);
+ stream.Close ();
+ }
+
+ [Test]
+ public void Flush ()
+ {
+ string path = TempFolder + DSC + "FileStreamTest.Flush";
+ FileStream stream = null;
+ FileStream stream2 = null;
+
+ DeleteFile (path);
+
+ try {
+ stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite);
+ stream2 = new FileStream (path, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
+
+ stream.Write (new byte[] { 1, 2, 3, 4, 5 }, 0, 5);
+
+ byte[] bytes = new byte[5];
+ stream2.Read (bytes, 0, 5);
+ Assert.AreEqual (0, bytes[0], "#A1");
+ Assert.AreEqual (0, bytes[1], "#A2");
+ Assert.AreEqual (0, bytes[2], "#A3");
+ Assert.AreEqual (0, bytes[3], "#A4");
+
+ stream.Flush ();
+ stream2.Read (bytes, 0, 5);
+ Assert.AreEqual (1, bytes[0], "#B1");
+ Assert.AreEqual (2, bytes[1], "#B2");
+ Assert.AreEqual (3, bytes[2], "#B3");
+ Assert.AreEqual (4, bytes[3], "#B4");
+ } finally {
+ if (stream != null)
+ stream.Close ();
+ if (stream2 != null)
+ stream2.Close ();
+
+ DeleteFile (path);
+ }
+ }
+
+ public void TestDefaultProperties ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "testfilestream.tmp.2";
+ DeleteFile (path);
+
+ FileStream stream = new FileStream (path, FileMode.Create);
+
+ Assert.IsTrue (stream.CanRead, "#A1");
+ Assert.IsTrue (stream.CanSeek, "#A2");
+ Assert.IsTrue (stream.CanWrite, "#A3");
+ Assert.IsFalse (stream.IsAsync, "#A4");
+ Assert.IsTrue (stream.Name.EndsWith (path), "#A5");
+ Assert.AreEqual (0, stream.Position, "#A6");
+ Assert.AreEqual ("System.IO.FileStream", stream.ToString (), "#A7");
+ stream.Close ();
+ DeleteFile (path);
+
+ stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read);
+ Assert.IsTrue (stream.CanRead, "#B1");
+ Assert.IsTrue (stream.CanSeek, "#B2");
+ Assert.IsFalse (stream.CanWrite, "#B3");
+ Assert.IsFalse (stream.IsAsync, "#B4");
+ Assert.IsTrue (stream.Name.EndsWith (path), "#B5");
+ Assert.AreEqual (0, stream.Position, "#B6");
+ Assert.AreEqual ("System.IO.FileStream", stream.ToString (), "#B7");
+ stream.Close ();
+
+ stream = new FileStream (path, FileMode.Truncate, FileAccess.Write, FileShare.ReadWrite);
+ Assert.IsFalse (stream.CanRead, "#C1");
+ Assert.IsTrue (stream.CanSeek, "#C2");
+ Assert.IsTrue (stream.CanWrite, "#C3");
+ Assert.IsFalse (stream.IsAsync, "#C4");
+ Assert.IsTrue (stream.Name.EndsWith ("testfilestream.tmp.2"), "#C5");
+ Assert.AreEqual (0, stream.Position, "#C6");
+ Assert.AreEqual ("System.IO.FileStream", stream.ToString (), "#C7");
+ stream.Close ();
+ DeleteFile (path);
+ }
+
+ [Category ("NotWorking")]
+ // Bug: 71371 -> duplicate and WONTFIX.
+ public void TestLock_FailsOnMono ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "TestLock";
+ DeleteFile (path);
+
+ FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite);
+
+ stream.Write (new Byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, 0, 10);
+ stream.Close ();
+
+ stream = new FileStream (path, FileMode.Open, FileAccess.ReadWrite);
+
+ stream.Lock (0, 5);
+
+ FileStream stream2 = new FileStream (path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+
+ byte[] bytes = new byte[5];
+ try {
+ stream2.Read (bytes, 0, 5);
+ Assert.Fail ("#1");
} catch (Exception e) {
- AssertEquals ("test#03", typeof (ObjectDisposedException), e.GetType ());
+ Assert.AreEqual (typeof (IOException), e.GetType (), "#2");
}
-
- try {
+
+ stream.Close ();
+ stream2.Close ();
+
+ DeleteFile (path);
+ }
+
+ [Category("TargetJvmNotSupported")] // File locking not supported for TARGET_JVM
+ public void TestLock ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "TestLock";
+ DeleteFile (path);
+
+ FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite);
+
+ stream.Write (new Byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, 0, 10);
+ stream.Close ();
+
+ stream = new FileStream (path, FileMode.Open, FileAccess.ReadWrite);
+
+ stream.Lock (0, 5);
+
+ FileStream stream2 = new FileStream (path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+
+ byte[] bytes = new byte[5];
+ try {
+ stream2.Read (bytes, 0, 5);
+ Assert.Fail ("#A1");
+ } catch (Exception) {
+ // Bug #71371: on MS.NET you get an IOException detailing a lock
+ // Assert.AreEqual (typeof (IOException), e.GetType (), "#A2");
+ }
+
+ stream2.Seek (5, SeekOrigin.Begin);
+ stream2.Read (bytes, 0, 5);
+
+ Assert.AreEqual (5, bytes[0], "#B1");
+ Assert.AreEqual (6, bytes[1], "#B2");
+ Assert.AreEqual (7, bytes[2], "#B3");
+ Assert.AreEqual (8, bytes[3], "#B4");
+ Assert.AreEqual (9, bytes[4], "#B5");
+
+ stream.Unlock (0, 5);
+ stream2.Seek (0, SeekOrigin.Begin);
+ stream2.Read (bytes, 0, 5);
+
+ Assert.AreEqual (0, bytes[0], "#C1");
+ Assert.AreEqual (1, bytes[1], "#C2");
+ Assert.AreEqual (2, bytes[2], "#C3");
+ Assert.AreEqual (3, bytes[3], "#C4");
+ Assert.AreEqual (4, bytes[4], "#C5");
+
+ stream.Close ();
+ stream2.Close ();
+
+ DeleteFile (path);
+ }
+
+ [Test]
+ public void Seek ()
+ {
+ string path = TempFolder + DSC + "FST.Seek.Test";
+ DeleteFile (path);
+
+ FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite);
+ FileStream stream2 = new FileStream (path, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
+
+ stream.Write (new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 10 }, 0, 9);
+ Assert.AreEqual (5, stream2.Seek (5, SeekOrigin.Begin), "#1");
+ Assert.AreEqual (-1, stream2.ReadByte (), "#2");
+
+ Assert.AreEqual (2, stream2.Seek (-3, SeekOrigin.Current), "#3");
+ Assert.AreEqual (-1, stream2.ReadByte (), "#4");
+
+ Assert.AreEqual (12, stream.Seek (3, SeekOrigin.Current), "#5");
+ Assert.AreEqual (-1, stream.ReadByte (), "#6");
+
+ Assert.AreEqual (5, stream.Seek (-7, SeekOrigin.Current), "#7");
+ Assert.AreEqual (6, stream.ReadByte (), "#8");
+
+ Assert.AreEqual (5, stream2.Seek (5, SeekOrigin.Begin), "#9");
+ Assert.AreEqual (6, stream2.ReadByte (), "#10");
+
+ stream.Close ();
+ stream2.Close ();
+
+ DeleteFile (path);
+ }
+
+ public void TestSeek ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "TestSeek";
+ DeleteFile (path);
+
+ FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite);
+ stream.Write (new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, 0, 10);
+
+ stream.Seek (5, SeekOrigin.End);
+ Assert.AreEqual (-1, stream.ReadByte (), "#1");
+
+ stream.Seek (-5, SeekOrigin.End);
+ Assert.AreEqual (6, stream.ReadByte (), "#2");
+
+ try {
+ stream.Seek (-11, SeekOrigin.End);
+ Assert.Fail ("#3");
+ } catch (Exception e) {
+ Assert.AreEqual (typeof (IOException), e.GetType (), "#4");
+ }
+
+ stream.Seek (19, SeekOrigin.Begin);
+ Assert.AreEqual (-1, stream.ReadByte (), "#5");
+
+ stream.Seek (1, SeekOrigin.Begin);
+ Assert.AreEqual (2, stream.ReadByte (), "#6");
+
+ stream.Seek (3, SeekOrigin.Current);
+ Assert.AreEqual (6, stream.ReadByte (), "#7");
+
+ stream.Seek (-2, SeekOrigin.Current);
+ Assert.AreEqual (5, stream.ReadByte (), "#8");
+
+ stream.Flush ();
+
+ // Test that seeks work correctly when seeking inside the buffer
+ stream.Seek (0, SeekOrigin.Begin);
+ stream.WriteByte (0);
+ stream.WriteByte (1);
+ stream.Seek (0, SeekOrigin.Begin);
+ byte[] buf = new byte[1];
+ buf[0] = 2;
+ stream.Write (buf, 0, 1);
+ stream.Write (buf, 0, 1);
+ stream.Flush ();
+ stream.Seek (0, SeekOrigin.Begin);
+ Assert.AreEqual (2, stream.ReadByte (), "#9");
+ Assert.AreEqual (2, stream.ReadByte (), "#10");
+
+ stream.Close ();
+
+ DeleteFile (path);
+ }
+
+ public void TestClose ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "TestClose";
+ DeleteFile (path);
+
+ FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite);
+
+ stream.Write (new byte[] { 1, 2, 3, 4 }, 0, 4);
+ stream.ReadByte ();
+ stream.Close ();
+
+ try {
+ stream.ReadByte ();
+ Assert.Fail ("#A1");
+ } catch (Exception e) {
+ Assert.AreEqual (typeof (ObjectDisposedException), e.GetType (), "#A2");
+ }
+
+ try {
+ stream.WriteByte (64);
+ Assert.Fail ("#B1");
+ } catch (Exception e) {
+ Assert.AreEqual (typeof (ObjectDisposedException), e.GetType (), "#B2");
+ }
+
+ try {
+ stream.Flush ();
+ Assert.Fail ("#C1");
+ } catch (Exception e) {
+ Assert.AreEqual (typeof (ObjectDisposedException), e.GetType (), "#C2");
+ }
+
+ try {
long l = stream.Length;
- Fail ();
+ Assert.Fail ("#D1");
} catch (Exception e) {
- AssertEquals ("test#04", typeof (ObjectDisposedException), e.GetType ());
+ Assert.AreEqual (typeof (ObjectDisposedException), e.GetType (), "#D2");
}
-
- try {
+
+ try {
long l = stream.Position;
- Fail ();
+ Assert.Fail ("#E1");
} catch (Exception e) {
- AssertEquals ("test#05", typeof (ObjectDisposedException), e.GetType ());
+ Assert.AreEqual (typeof (ObjectDisposedException), e.GetType (), "#E2");
}
- AssertEquals ("test#06", false, stream.CanRead);
- AssertEquals ("test#07", false, stream.CanSeek);
- AssertEquals ("test#08", false, stream.CanWrite);
- AssertEquals ("test#09", true, stream.Name.EndsWith (path));
+ Assert.IsFalse (stream.CanRead, "#F1");
+ Assert.IsFalse (stream.CanSeek, "#F2");
+ Assert.IsFalse (stream.CanWrite, "#F3");
+ Assert.IsTrue (stream.Name.EndsWith (path), "#F4");
- DeleteFile (path);
- }
+ DeleteFile (path);
+ }
/// <summary>
/// <see cref="FileStream.Write(byte[], int, int)" /> method is called.
/// </summary>
[Test]
- [ExpectedException (typeof(NotSupportedException))]
+ [ExpectedException (typeof (NotSupportedException))]
public void TestWriteVerifyAccessMode ()
{
string path = TempFolder + Path.DirectorySeparatorChar + "temp";
stream.Write (buffer, 0, buffer.Length);
} finally {
if (stream != null)
- stream.Close();
+ stream.Close ();
DeleteFile (path);
}
}
DeleteFile (path);
FileStream stream = null;
- byte[] buffer = new byte [100];
+ byte[] buffer = new byte[100];
try {
stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write);
int readByte = stream.ReadByte ();
} finally {
if (stream != null)
- stream.Close();
+ stream.Close ();
DeleteFile (path);
}
}
- private void DeleteFile (string path)
+#if !TARGET_JVM // No support IntPtr file handles under TARGET_JVM
+ // Check that the stream is flushed even when it doesn't own the
+ // handle
+ [Test]
+ public void TestFlushNotOwningHandle ()
+ {
+ string path = Path.Combine (TempFolder, "TestFlushNotOwningHandle");
+ DeleteFile (path);
+
+ FileStream s = new FileStream (path, FileMode.Create);
+ using (FileStream s2 = new FileStream (s.Handle, FileAccess.Write, false)) {
+ byte[] buf = new byte[2];
+ buf[0] = (int) '1';
+ s2.Write (buf, 0, 1);
+ }
+
+ s.Position = 0;
+ Assert.AreEqual ((int) '1', s.ReadByte ());
+ s.Close ();
+ }
+#endif // TARGET_JVM
+
+ private void DeleteFile (string path)
{
if (File.Exists (path))
File.Delete (path);
}
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void Read_OffsetNegative ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+
+ using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read)) {
+ stream.Read (new byte[0], -1, 1);
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void Read_OffsetOverflow ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+
+ using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read)) {
+ stream.Read (new byte[0], Int32.MaxValue, 1);
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void Read_CountNegative ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+
+ using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read)) {
+ stream.Read (new byte[0], 1, -1);
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void Read_CountOverflow ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+
+ using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read)) {
+ stream.Read (new byte[0], 1, Int32.MaxValue);
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void Write_OffsetNegative ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+
+ using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write)) {
+ stream.Write (new byte[0], -1, 1);
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void Write_OffsetOverflow ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+
+ using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write)) {
+ stream.Write (new byte[0], Int32.MaxValue, 1);
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void Write_CountNegative ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+
+ using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write)) {
+ stream.Write (new byte[0], 1, -1);
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void Write_CountOverflow ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+
+ using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write)) {
+ stream.Write (new byte[0], 1, Int32.MaxValue);
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void Seek_InvalidSeekOrigin ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+
+ using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read)) {
+ stream.Seek (0, (SeekOrigin) (-1));
+ }
+ }
+
+#if !TARGET_JVM // No support IntPtr file handles under TARGET_JVM
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void Constructor_InvalidFileHandle ()
+ {
+ new FileStream ((IntPtr) (-1L), FileAccess.Read);
+ }
+#endif // TARGET_JVM
+
+ [Test]
+ public void PositionAfterSetLength ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+
+ using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write)) {
+ stream.SetLength (32);
+ stream.Position = 32;
+ stream.SetLength (16);
+ Assert.AreEqual (16, stream.Position);
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (ObjectDisposedException))]
+ public void SetLength_Disposed ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+ FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write);
+ stream.Close ();
+ stream.SetLength (16);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ObjectDisposedException))]
+ public void Position_Disposed ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+ FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read);
+ stream.Close ();
+ stream.Position = 0;
+ }
+
+ [Test]
+ [Category("TargetJvmNotSupported")] // Async IO not supported for TARGET_JVM
+ [ExpectedException (typeof (ObjectDisposedException))]
+ public void BeginRead_Disposed ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+ FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read);
+ stream.Close ();
+ stream.EndRead (stream.BeginRead (new byte[8], 0, 8, null, null));
+ }
+
+ [Test]
+ [Category("TargetJvmNotSupported")] // Async IO not supported for TARGET_JVM
+ [ExpectedException (typeof (ObjectDisposedException))]
+ public void BeginWrite_Disposed ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+ FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write);
+ stream.Close ();
+ stream.EndWrite (stream.BeginWrite (new byte[8], 0, 8, null, null));
+ }
+
+ [Test]
+ [Category("TargetJvmNotSupported")] // File locking not supported for TARGET_JVM
+ [ExpectedException (typeof (ObjectDisposedException))]
+ public void Lock_Disposed ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+ FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write);
+ stream.Close ();
+ stream.Lock (0, 1);
+ }
+
+ [Test]
+ [Category("TargetJvmNotSupported")] // File locking not supported for TARGET_JVM
+ [ExpectedException (typeof (ObjectDisposedException))]
+ public void Unlock_Disposed ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+ FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write);
+ stream.Close ();
+ stream.Unlock (0, 1);
+ }
+
+ [Test]
+ public void ReadBytePastEndOfStream ()
+ {
+ string path = TempFolder + Path.DirectorySeparatorChar + "temp";
+ DeleteFile (path);
+ using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read)) {
+ stream.Seek (0, SeekOrigin.End);
+ Assert.AreEqual (-1, stream.ReadByte ());
+ stream.Close ();
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (NotSupportedException))]
+ public void SetLengthWithClosedBaseStream ()
+ {
+ string fn = Path.Combine (TempFolder, "temp");
+ try {
+ FileStream fs = new FileStream (fn, FileMode.Create);
+ BufferedStream bs = new BufferedStream (fs);
+ fs.Close ();
+
+ bs.SetLength (1000);
+ } finally {
+ File.Delete (fn);
+ }
+ }
+
+ [Test]
+ public void LengthAfterWrite ()
+ {
+ string path = TempFolder + DSC + "oneofthefilescreated.txt";
+ FileStream fs = null;
+ DeleteFile (path);
+ try {
+ fs = new FileStream (path, FileMode.CreateNew);
+ fs.WriteByte (Convert.ToByte ('A'));
+ byte [] buffer = Encoding.ASCII.GetBytes (" is a first character.");
+ fs.Write (buffer, 0, buffer.Length);
+ fs.Seek (0, SeekOrigin.Begin);
+ char a = Convert.ToChar (fs.ReadByte ());
+ Assert.AreEqual ('A', a, "#A1");
+ Assert.AreEqual (23, fs.Length, "#A2");
+ int nread = fs.Read (buffer, 0, 5);
+ Assert.AreEqual (5, nread, "#A3");
+ } finally {
+ if (fs != null)
+ fs.Close ();
+ DeleteFile (path);
+ }
+ }
+
+#if NET_2_0
+ [Category("TargetJvmNotSupported")] // FileOptions.DeleteOnClose not supported for TARGET_JVM
+ [Test]
+ public void DeleteOnClose ()
+ {
+ string path = TempFolder + DSC + "created.txt";
+ DeleteFile (path);
+ FileStream fs = new FileStream (path, FileMode.CreateNew, FileAccess.Write, FileShare.None, 1024,
+ FileOptions.DeleteOnClose);
+ Assert.AreEqual (true, File.Exists (path), "DOC#1");
+ fs.Close ();
+ Assert.AreEqual (false, File.Exists (path), "DOC#2");
-
- }
+ }
+#endif
+ }
}
-
projects / mono.git / blobdiff