* roottypes.cs: Rename from tree.cs.

[mono.git] / mcs / class / corlib / Test / System.IO / FileStreamCas.cs

diff --git a/mcs/class/corlib/Test/System.IO/FileStreamCas.cs b/mcs/class/corlib/Test/System.IO/FileStreamCas.cs
index 68277dcd0d69837c63bc7876ef21cfa2d93e30b9..17f09f13e6c107f492c066085409f38956d58cf2 100644 (file)
--- a/mcs/class/corlib/Test/System.IO/FileStreamCas.cs
+++ b/mcs/class/corlib/Test/System.IO/FileStreamCas.cs
@@ -33,6 +33,7 @@ using System.IO;
 using System.Reflection;
 using System.Security;
 using System.Security.Permissions;
+using System.Threading;
 
 namespace MonoCasTests.System.IO {
 
@@ -41,12 +42,31 @@ namespace MonoCasTests.System.IO {
        public class FileStreamCas {
 
                private MonoTests.System.IO.FileStreamTest fst;
+               private const int timeout = 30000;
+               private string message;
+               private string readfile;
+               private string writefile;
+
+               static ManualResetEvent reset;
 
                [TestFixtureSetUp]
                public void FixtureSetUp ()
                {
                        // this occurs with a "clean" stack (full trust)
                        fst  = new MonoTests.System.IO.FileStreamTest ();
+                       reset = new ManualResetEvent (false);
+                       readfile = Path.GetTempFileName ();
+                       writefile = Path.GetTempFileName ();
+               }
+
+               [TestFixtureTearDown]
+               public void FixtureTearDown ()
+               {
+                       reset.Close ();
+                       if (File.Exists (readfile))
+                               File.Delete (readfile);
+                       if (File.Exists (writefile))
+                               File.Delete (writefile);
                }
 
                [SetUp]
@@ -161,5 +181,73 @@ namespace MonoCasTests.System.IO {
                                fs.Close ();
                        }
                }
+
+               // async tests (for stack propagation)
+
+               private void ReadCallback (IAsyncResult ar)
+               {
+                       FileStream s = (FileStream)ar.AsyncState;
+                       s.EndRead (ar);
+                       try {
+                               // can we do something bad here ?
+                               Assert.IsNotNull (Environment.GetEnvironmentVariable ("USERNAME"));
+                               message = "Expected a SecurityException";
+                       }
+                       catch (SecurityException) {
+                               message = null;
+                               reset.Set ();
+                       }
+                       catch (Exception e) {
+                               message = e.ToString ();
+                       }
+               }
+
+               [Test]
+               [EnvironmentPermission (SecurityAction.Deny, Read = "USERNAME")]
+               public void AsyncRead ()
+               {
+                       FileStream fs = new FileStream (readfile, FileMode.OpenOrCreate);
+                       message = "AsyncRead";
+                       reset.Reset ();
+                       IAsyncResult r = fs.BeginRead (new byte[0], 0, 0, new AsyncCallback (ReadCallback), fs);
+                       Assert.IsNotNull (r, "IAsyncResult");
+                       if (!reset.WaitOne (timeout, true))
+                               Assert.Ignore ("Timeout");
+                       Assert.IsNull (message, message);
+                       fs.Close ();
+               }
+
+               private void WriteCallback (IAsyncResult ar)
+               {
+                       FileStream s = (FileStream)ar.AsyncState;
+                       s.EndWrite (ar);
+                       try {
+                               // can we do something bad here ?
+                               Assert.IsNotNull (Environment.GetEnvironmentVariable ("USERNAME"));
+                               message = "Expected a SecurityException";
+                       }
+                       catch (SecurityException) {
+                               message = null;
+                               reset.Set ();
+                       }
+                       catch (Exception e) {
+                               message = e.ToString ();
+                       }
+               }
+
+               [Test]
+               [EnvironmentPermission (SecurityAction.Deny, Read = "USERNAME")]
+               public void AsyncWrite ()
+               {
+                       FileStream fs = new FileStream (writefile, FileMode.OpenOrCreate);
+                       message = "AsyncWrite";
+                       reset.Reset ();
+                       IAsyncResult r = fs.BeginWrite (new byte[0], 0, 0, new AsyncCallback (WriteCallback), fs);
+                       Assert.IsNotNull (r, "IAsyncResult");
+                       if (!reset.WaitOne (timeout, true))
+                               Assert.Ignore ("Timeout");
+                       Assert.IsNull (message, message);
+                       fs.Close ();
+               }
        }
 }