diff options
Diffstat (limited to 'mcs/class/Mono.Posix/Test/Mono.Unix/StdioFileStreamTest.cs')
| -rw-r--r-- | mcs/class/Mono.Posix/Test/Mono.Unix/StdioFileStreamTest.cs | 813 |
1 files changed, 813 insertions, 0 deletions
diff --git a/mcs/class/Mono.Posix/Test/Mono.Unix/StdioFileStreamTest.cs b/mcs/class/Mono.Posix/Test/Mono.Unix/StdioFileStreamTest.cs new file mode 100644 index 00000000000..a4e1e7fdad4 --- /dev/null +++ b/mcs/class/Mono.Posix/Test/Mono.Unix/StdioFileStreamTest.cs @@ -0,0 +1,813 @@ +// StdioFileStreamTest.cs - NUnit2 Test Cases for Mono.Unix.StdioFileStream class +// +// Authors: +// Ville Palo (vi64pa@koti.soon.fi) +// Gert Driesen (gert.driesen@ardatis.com) +// Gonzalo Paniagua Javier (gonzalo@ximian.com) +// +// (C) Ville Palo +// (c) 2003 Ximian, Inc. (http://www.ximian.com) +// + + +using NUnit.Framework; +using System; +using System.IO; +using System.Text; +using Mono.Unix; + +namespace MonoTests.System.IO +{ + [TestFixture] + public class StdioFileStreamTest { + + string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.Mono.Unix.Tests"); + static readonly char DSC = Path.DirectorySeparatorChar; + + [TearDown] + public void TearDown() + { + if (Directory.Exists (TempFolder)) + Directory.Delete (TempFolder, true); + } + + [SetUp] + public void SetUp () + { + if (Directory.Exists (TempFolder)) + Directory.Delete (TempFolder, true); + + Directory.CreateDirectory (TempFolder); + } + + public void TestCtr () + { + string path = TempFolder + DSC + "testfilestream.tmp.1"; + DeleteFile (path); + StdioFileStream stream = null; + try { + stream = new StdioFileStream (path, FileMode.Create); + } finally { + + if (stream != null) + stream.Close (); + DeleteFile (path); + } + } + + [Test] + [ExpectedException (typeof (ArgumentException))] + public void CtorArgumentException1 () + { + StdioFileStream stream; + stream = new StdioFileStream ("", FileMode.Create); + stream.Close (); + } + + [Test] + [ExpectedException (typeof (ArgumentNullException))] + public void CtorArgumentNullException () + { + StdioFileStream stream = new StdioFileStream (null, FileMode.Create); + stream.Close (); + } + + [Test] + [ExpectedException (typeof (FileNotFoundException))] + public void CtorFileNotFoundException1 () + { + string path = TempFolder + DSC + "thisfileshouldnotexists.test"; + DeleteFile (path); + StdioFileStream stream = null; + try { + stream = new StdioFileStream (path, FileMode.Open); + } finally { + if (stream != null) + stream.Close (); + DeleteFile (path); + } + } + + [Test] + [ExpectedException (typeof (FileNotFoundException))] + public void CtorFileNotFoundException2 () + { + string path = TempFolder + DSC + "thisfileshouldNOTexists.test"; + DeleteFile (path); + StdioFileStream stream = null; + + try { + stream = new StdioFileStream (path, FileMode.Truncate); + } finally { + if (stream != null) + stream.Close (); + + DeleteFile (path); + } + } + + [Test] + [ExpectedException (typeof (IOException))] + public void CtorIOException1 () + { + string path = TempFolder + DSC + "thisfileshouldexists.test"; + StdioFileStream stream = null; + DeleteFile (path); + try { + stream = new StdioFileStream (path, FileMode.CreateNew); + stream.Close (); + stream = null; + stream = new StdioFileStream (path, FileMode.CreateNew); + } finally { + + if (stream != null) + stream.Close (); + DeleteFile (path); + } + } + + [Test] + [ExpectedException (typeof (ArgumentOutOfRangeException))] + public void CtorArgumentOutOfRangeException1 () + { + StdioFileStream stream = null; + string path = TempFolder + Path.DirectorySeparatorChar + "temp"; + DeleteFile (path); + try { + stream = new StdioFileStream (path, FileMode.Append | FileMode.CreateNew); + } finally { + if (stream != null) + stream.Close (); + DeleteFile (path); + } + } + + [Test] + [ExpectedException (typeof (ArgumentOutOfRangeException))] + public void CtorArgumentOutOfRangeException2 () + { + StdioFileStream stream = null; + string path = TempFolder + Path.DirectorySeparatorChar + "temp"; + DeleteFile (path); + try { + stream = new StdioFileStream ("test.test.test", FileMode.Append | FileMode.Open); + } finally { + if (stream != null) + stream.Close (); + DeleteFile (path); + } + } + + [Test] + [ExpectedException (typeof (DirectoryNotFoundException))] + public void CtorDirectoryNotFoundException () + { + string path = TempFolder + DSC + "thisDirectoryShouldNotExists"; + if (Directory.Exists (path)) + Directory.Delete (path, true); + + StdioFileStream stream = null; + try { + stream = new StdioFileStream (path + DSC + "eitherthisfile.test", FileMode.CreateNew); + } finally { + + if (stream != null) + stream.Close (); + + if (Directory.Exists (path)) + Directory.Delete (path, true); + } + } + + [Test] + [ExpectedException (typeof (ArgumentException))] + public void CtorArgumentException3 () + { + string path = TempFolder + Path.DirectorySeparatorChar + "temp"; + StdioFileStream stream = null; + + DeleteFile (path); + + try { + stream = new StdioFileStream (".test.test.test.2", FileMode.Truncate, FileAccess.Read); + } finally { + if (stream != null) + stream.Close (); + + DeleteFile (path); + } + } + + // StdioFileStream doesn't mimic the "no writing by another object" rule + [/* Test, */ ExpectedException(typeof(IOException))] + public void CtorIOException () + { + string path = TempFolder + DSC + "CTorIOException.Test"; + StdioFileStream stream = null; + StdioFileStream stream2 = null; + DeleteFile (path); + + try { + stream = new StdioFileStream (path, FileMode.CreateNew); + + // used by an another process + stream2 = new StdioFileStream (path, FileMode.OpenOrCreate); + } finally { + if (stream != null) + stream.Close (); + if (stream2 != null) + stream2.Close (); + DeleteFile (path); + } + } + + [Test] + public void CtorAccess1Read2Read () + { + StdioFileStream fs = null; + StdioFileStream fs2 = null; + try { + if (!File.Exists ("temp")) { + TextWriter tw = File.CreateText ("temp"); + tw.Write ("FOO"); + tw.Close (); + } + fs = new StdioFileStream ("temp", FileMode.Open, FileAccess.Read); + fs2 = new StdioFileStream ("temp", FileMode.Open, FileAccess.Read); + } finally { + if (fs != null) + fs.Close (); + if (fs2 != null) + fs2.Close (); + if (File.Exists ("temp")) + File.Delete ("temp"); + } + } + + [Test] + public void Write () + { + string path = TempFolder + DSC + "StdioFileStreamTest.Write"; + + DeleteFile (path); + + StdioFileStream stream = new StdioFileStream (path, FileMode.CreateNew, FileAccess.ReadWrite); + + 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]); + + // 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]); + stream.Close (); + } + + [Test] + public void Length () + { + // Test that the Length property takes into account the data + // in the buffer + string path = TempFolder + DSC + "StdioFileStreamTest.Length"; + + DeleteFile (path); + + StdioFileStream stream = new StdioFileStream (path, FileMode.CreateNew); + + byte[] outbytes = new byte [] {1, 2, 3, 4}; + + stream.Write (outbytes, 0, 4); + Assert.AreEqual (stream.Length, 4); + stream.Close (); + } + + [Test] + public void Flush () + { + string path = TempFolder + DSC + "StdioFileStreamTest.Flush"; + StdioFileStream stream = null; + StdioFileStream stream2 = null; + + DeleteFile (path); + + try { + stream = new StdioFileStream (path, FileMode.CreateNew, FileAccess.ReadWrite); + stream2 = new StdioFileStream (path, FileMode.Open, FileAccess.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], "test#01"); + Assert.AreEqual (0, bytes [1], "test#02"); + Assert.AreEqual (0, bytes [2], "test#03"); + Assert.AreEqual (0, bytes [3], "test#04"); + + stream.Flush (); + stream2.Read (bytes, 0, 5); + Assert.AreEqual (1, bytes [0], "test#05"); + Assert.AreEqual (2, bytes [1], "test#06"); + Assert.AreEqual (3, bytes [2], "test#07"); + Assert.AreEqual (4, bytes [3], "test#08"); + } finally { + if (stream != null) + stream.Close (); + if (stream2 != null) + stream2.Close (); + + DeleteFile (path); + } + } + + [Test] + public void TestDefaultProperties () + { + string path = TempFolder + Path.DirectorySeparatorChar + "testStdioFileStream.tmp.2"; + DeleteFile (path); + + StdioFileStream stream = new StdioFileStream (path, FileMode.Create); + + Assert.AreEqual (true, stream.CanRead, "test#01"); + Assert.AreEqual (true, stream.CanSeek, "test#02"); + Assert.AreEqual (true, stream.CanWrite, "test#03"); + Assert.AreEqual (0, stream.Position, "test#06"); + Assert.AreEqual ("Mono.Unix.StdioFileStream", stream.ToString(), "test#07"); + stream.Close (); + DeleteFile (path); + + stream = new StdioFileStream (path, FileMode.OpenOrCreate, FileAccess.Read); + Assert.AreEqual (true, stream.CanRead, "test#08"); + Assert.AreEqual (true, stream.CanSeek, "test#09"); + Assert.AreEqual (false, stream.CanWrite, "test#10"); + Assert.AreEqual (0, stream.Position, "test#13"); + Assert.AreEqual ("Mono.Unix.StdioFileStream", stream.ToString(), "test#14"); + stream.Close (); + + stream = new StdioFileStream (path, FileMode.Truncate, FileAccess.Write); + Assert.AreEqual (false, stream.CanRead, "test#15"); + Assert.AreEqual (true, stream.CanSeek, "test#16"); + Assert.AreEqual (true, stream.CanWrite, "test#17"); + Assert.AreEqual (0, stream.Position, "test#20"); + Assert.AreEqual ("Mono.Unix.StdioFileStream", stream.ToString(), "test#21"); + stream.Close (); + DeleteFile (path); + } + + [Test] + public void Seek () + { + string path = TempFolder + DSC + "FST.Seek.Test"; + DeleteFile (path); + + StdioFileStream stream = new StdioFileStream (path, FileMode.CreateNew, FileAccess.ReadWrite); + StdioFileStream stream2 = new StdioFileStream (path, FileMode.Open, FileAccess.ReadWrite); + + stream.Write (new byte [] {1, 2, 3, 4, 5, 6, 7, 8, 10}, 0, 9); + Assert.AreEqual (5, stream2.Seek (5, SeekOrigin.Begin), "test#01"); + Assert.AreEqual (-1, stream2.ReadByte (), "test#02"); + + Assert.AreEqual (2, stream2.Seek (-3, SeekOrigin.Current), "test#03"); + Assert.AreEqual (-1, stream2.ReadByte (), "test#04"); + + Assert.AreEqual (12, stream.Seek (3, SeekOrigin.Current), "test#05"); + Assert.AreEqual (-1, stream.ReadByte (), "test#06"); + + Assert.AreEqual (5, stream.Seek (-7, SeekOrigin.Current), "test#07"); + Assert.AreEqual (6, stream.ReadByte (), "test#08"); + + Assert.AreEqual (5, stream2.Seek (5, SeekOrigin.Begin), "test#09"); + Assert.AreEqual (6, stream2.ReadByte (), "test#10"); + + stream.Close (); + stream2.Close (); + + DeleteFile (path); + } + + [Test] + public void TestSeek () + { + string path = TempFolder + Path.DirectorySeparatorChar + "TestSeek"; + DeleteFile (path); + + StdioFileStream stream = new StdioFileStream (path, FileMode.CreateNew, FileAccess.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 (), "test#01"); + + stream.Seek (-5, SeekOrigin.End); + Assert.AreEqual (6, stream.ReadByte (), "test#02"); + + try { + stream.Seek (-11, SeekOrigin.End); + Assert.Fail (); + } catch (Exception e) { + Assert.AreEqual (typeof (IOException), e.GetType (), "test#03"); + } + + stream.Seek (19, SeekOrigin.Begin); + Assert.AreEqual (-1, stream.ReadByte (), "test#04"); + + stream.Seek (1, SeekOrigin.Begin); + Assert.AreEqual (2, stream.ReadByte (), "test#05"); + + stream.Seek (3, SeekOrigin.Current); + Assert.AreEqual (6, stream.ReadByte (), "test#06"); + + stream.Seek (-2, SeekOrigin.Current); + Assert.AreEqual (5, stream.ReadByte (), "test#07"); + + 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 (), "test#08"); + Assert.AreEqual (2, stream.ReadByte (), "test#09"); + + stream.Close (); + + DeleteFile (path); + } + + [Test] + public void TestClose () + { + string path = TempFolder + Path.DirectorySeparatorChar + "TestClose"; + DeleteFile (path); + + StdioFileStream stream = new StdioFileStream (path, FileMode.CreateNew, FileAccess.ReadWrite); + + stream.Write (new byte [] {1, 2, 3, 4}, 0, 4); + stream.ReadByte (); + stream.Close (); + + try { + stream.ReadByte (); + Assert.Fail (); + } catch (Exception e) { + Assert.AreEqual (typeof (ObjectDisposedException), e.GetType (), "test#01"); + } + + try { + stream.WriteByte (64); + Assert.Fail (); + } catch (Exception e) { + Assert.AreEqual (typeof (ObjectDisposedException), e.GetType (), "test#02"); + } + + try { + stream.Flush (); + Assert.Fail (); + } catch (Exception e) { + Assert.AreEqual (typeof (ObjectDisposedException), e.GetType (), "test#03"); + } + + try { + long l = stream.Length; + l = l; + Assert.Fail (); + } catch (Exception e) { + Assert.AreEqual (typeof (ObjectDisposedException), e.GetType (), "test#04"); + } + + try { + long l = stream.Position; + l = l; + Assert.Fail (); + } catch (Exception e) { + Assert.AreEqual (typeof (ObjectDisposedException), e.GetType (), "test#05"); + } + + Assert.AreEqual (false, stream.CanRead, "test#06"); + Assert.AreEqual (false, stream.CanSeek, "test#07"); + Assert.AreEqual (false, stream.CanWrite, "test#08"); + + DeleteFile (path); + } + + + /// <summary> + /// Checks whether the <see cref="StdioFileStream" /> throws a <see cref="NotSupportedException" /> + /// when the stream is opened with access mode <see cref="FileAccess.Read" /> and the + /// <see cref="StdioFileStream.Write(byte[], int, int)" /> method is called. + /// </summary> + [Test] + [ExpectedException (typeof(NotSupportedException))] + public void TestWriteVerifyAccessMode () + { + string path = TempFolder + Path.DirectorySeparatorChar + "temp"; + DeleteFile (path); + + StdioFileStream stream = null; + byte[] buffer; + + try { + buffer = Encoding.ASCII.GetBytes ("test"); + stream = new StdioFileStream (path, FileMode.OpenOrCreate, FileAccess.Read); + stream.Write (buffer, 0, buffer.Length); + } finally { + if (stream != null) + stream.Close(); + DeleteFile (path); + } + } + + /// <summary> + /// Checks whether the <see cref="StdioFileStream" /> throws a <see cref="NotSupportedException" /> + /// when the stream is opened with access mode <see cref="FileAccess.Read" /> and the + /// <see cref="StdioFileStream.WriteByte(byte)" /> method is called. + /// </summary> + [Test] + [ExpectedException (typeof (NotSupportedException))] + public void TestWriteByteVerifyAccessMode () + { + string path = TempFolder + Path.DirectorySeparatorChar + "temp"; + DeleteFile (path); + + StdioFileStream stream = null; + + try { + stream = new StdioFileStream (path, FileMode.OpenOrCreate, FileAccess.Read); + stream.WriteByte (Byte.MinValue); + } finally { + if (stream != null) + stream.Close (); + DeleteFile (path); + } + } + + /// <summary> + /// Checks whether the <see cref="StdioFileStream" /> throws a <see cref="NotSupportedException" /> + /// when the stream is opened with access mode <see cref="FileAccess.Write" /> and the + /// <see cref="StdioFileStream.Read(byte[], int, int)" /> method is called. + /// </summary> + [Test] + [ExpectedException (typeof (NotSupportedException))] + public void TestReadVerifyAccessMode () + { + string path = TempFolder + Path.DirectorySeparatorChar + "temp"; + DeleteFile (path); + + StdioFileStream stream = null; + byte[] buffer = new byte [100]; + + try { + stream = new StdioFileStream (path, FileMode.OpenOrCreate, FileAccess.Write); + stream.Read (buffer, 0, buffer.Length); + } finally { + if (stream != null) + stream.Close (); + } + } + + /// <summary> + /// Checks whether the <see cref="StdioFileStream" /> throws a <see cref="NotSupportedException" /> + /// when the stream is opened with access mode <see cref="FileAccess.Write" /> and the + /// <see cref="StdioFileStream.ReadByte()" /> method is called. + /// </summary> + [Test] + [ExpectedException (typeof (NotSupportedException))] + public void TestReadByteVerifyAccessMode () + { + string path = TempFolder + Path.DirectorySeparatorChar + "temp"; + DeleteFile (path); + + StdioFileStream stream = null; + + try { + stream = new StdioFileStream (path, FileMode.OpenOrCreate, FileAccess.Write); + int readByte = stream.ReadByte (); + readByte = readByte; + } finally { + if (stream != null) + stream.Close(); + DeleteFile (path); + } + } + + // 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); + + StdioFileStream s = new StdioFileStream (path, FileMode.Create); + using (StdioFileStream s2 = new StdioFileStream (s.Handle, FileAccess.Write, false)) { + byte[] buf = new byte [2]; + buf [0] = (int)'1'; + s2.Write (buf, 0, 1); + } + + s.Position = 0; + Assert.AreEqual (s.ReadByte (), (int)'1'); + s.Close (); + } + + 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 (StdioFileStream stream = new StdioFileStream (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 (StdioFileStream stream = new StdioFileStream (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 (StdioFileStream stream = new StdioFileStream (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 (StdioFileStream stream = new StdioFileStream (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 (StdioFileStream stream = new StdioFileStream (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 (StdioFileStream stream = new StdioFileStream (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 (StdioFileStream stream = new StdioFileStream (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 (StdioFileStream stream = new StdioFileStream (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 (StdioFileStream stream = new StdioFileStream (path, FileMode.OpenOrCreate, FileAccess.Read)) { + stream.Seek (0, (SeekOrigin) (-1)); + } + } + + [Test] + [ExpectedException (typeof (ArgumentException))] + public void Constructor_InvalidFileHandle () + { + new StdioFileStream ((IntPtr)(-1), FileAccess.Read); + } + + [Test] + [ExpectedException (typeof (ObjectDisposedException))] + public void Position_Disposed () + { + string path = TempFolder + Path.DirectorySeparatorChar + "temp"; + DeleteFile (path); + StdioFileStream stream = new StdioFileStream (path, FileMode.OpenOrCreate, FileAccess.Read); + stream.Close (); + stream.Position = 0; + } + + [Test] + [ExpectedException (typeof (ObjectDisposedException))] + public void Flush_Disposed () + { + string path = TempFolder + Path.DirectorySeparatorChar + "temp"; + DeleteFile (path); + StdioFileStream stream = new StdioFileStream (path, FileMode.OpenOrCreate, FileAccess.Write); + stream.Close (); + stream.Flush (); + } + + [Test] + [ExpectedException (typeof (ObjectDisposedException))] + public void Seek_Disposed () + { + string path = TempFolder + Path.DirectorySeparatorChar + "temp"; + DeleteFile (path); + StdioFileStream stream = new StdioFileStream (path, FileMode.OpenOrCreate, FileAccess.Write); + stream.Close (); + stream.Seek (0, SeekOrigin.Begin); + } + + [Test] + public void ReadBytePastEndOfStream () + { + string path = TempFolder + Path.DirectorySeparatorChar + "temp"; + DeleteFile (path); + using (StdioFileStream stream = new StdioFileStream (path, FileMode.OpenOrCreate, FileAccess.Read)) { + stream.Seek (0, SeekOrigin.End); + Assert.AreEqual (-1, stream.ReadByte (), "ReadByte"); + stream.Close (); + } + } + + [Test] + [ExpectedException (typeof (NotSupportedException))] + public void SetLengthWithClosedBaseStream () + { + StdioFileStream fs = new StdioFileStream ("temp", FileMode.Create); + BufferedStream bs = new BufferedStream (fs); + fs.Close (); + + bs.SetLength (1000); + } + } +} + |