mcs/class/System/Test/System.Net/FileWebRequestTest.cs

   1 //
   2 // FileWebRequestTest.cs - NUnit Test Cases for System.Net.FileWebRequest
   3 //
   4 // Authors:
   5 //   Lawrence Pit (loz@cable.a2000.nl)
   6 //   Martin Willemoes Hansen (mwh@sysrq.dk)
   7 //
   8 // (C) 2003 Martin Willemoes Hansen
   9 //
  10
  11 using NUnit.Framework;
  12 using System;
  13 using System.IO;
  14 using System.Net;
  15 using System.Collections;
  16 using System.Security;
  17 using System.Security.Permissions;
  18
  19 namespace MonoTests.System.Net
  20 {
  21
  22 [TestFixture]
  23 public class FileWebRequestTest
  24 {
  25         [Test]
  26         public void Async ()
  27         {
  28                 string tmpFilename = GetFilename ();
  29                 if (tmpFilename == null) {
  30                         Console.WriteLine ("\n\nSet environment variable TMPDIR to a temporary directory to test FileWebRequest\n");
  31                         return;
  32                 }
  33
  34                 try {
  35                         if (File.Exists (tmpFilename))
  36                                 File.Delete (tmpFilename);
  37
  38                         Uri uri = new Uri ("file:///" + tmpFilename);
  39
  40                         WebRequest req = WebRequest.Create (uri);
  41                         req.Method = "PUT";
  42
  43                         req.Timeout = 2 * 1000;
  44                         IAsyncResult async = req.BeginGetRequestStream (null, null);
  45                         try {
  46                                 req.BeginGetRequestStream (null, null);
  47                                 Assertion.Fail ("#1 should've failed");
  48                         } catch (InvalidOperationException) {
  49                                 //Console.WriteLine ("GOT1: " + e.Message + "\n" + e.StackTrace);
  50                                 // Cannot re-call BeginGetRequestStream/BeginGetResponse while
  51                                 // a previous call is still in progress
  52                         }
  53                         /*
  54                         try {
  55                                 req.BeginGetResponse (null, null);
  56                                 Assertion.Fail ("#2 should've failed");
  57                         } catch (InvalidOperationException) { }
  58                         */
  59                         try {
  60                                 req.GetRequestStream ();
  61                                 Assertion.Fail ("#3 should've failed");
  62                         } catch (InvalidOperationException) {
  63                                 // Console.WriteLine ("GOT3: " + e.Message + "\n" + e.StackTrace);
  64                                 // Cannot re-call BeginGetRequestStream/BeginGetResponse while
  65                                 // a previous call is still in progress
  66                         }
  67
  68                         try {
  69                                 req.GetResponse ();
  70                                 Assertion.Fail ("#4 should've failed");
  71                         } catch (WebException) {
  72                                 // Console.WriteLine ("4: " + e.Message + "\n" + e.StackTrace);
  73                                 // The operation has timed out
  74                         }
  75
  76                         try {
  77                                 IAsyncResult async0 = req.BeginGetResponse (null, null);
  78                                 req.EndGetResponse (async0);
  79                                 // Console.WriteLine ("X5c");
  80                                 Assertion.Fail ("#5 should've failed");
  81                         } catch (InvalidOperationException) {
  82                                 // Console.WriteLine ("5e: " + e.Message + "\n" + e.StackTrace);
  83                                 // Cannot re-call BeginGetRequestStream/BeginGetResponse while
  84                                 // a previous call is still in progress
  85                         }
  86
  87                         // Console.WriteLine ("WEBHEADERS: " + req.Headers);
  88
  89                         Stream wstream = req.EndGetRequestStream (async);
  90                         Assertion.AssertEquals ("#1r", false, wstream.CanRead);
  91                         Assertion.AssertEquals ("#1w", true, wstream.CanWrite);
  92                         Assertion.AssertEquals ("#1s", true, wstream.CanSeek);
  93
  94                         wstream.WriteByte (72);
  95                         wstream.WriteByte (101);
  96                         wstream.WriteByte (108);
  97                         wstream.WriteByte (108);
  98                         wstream.WriteByte (111);
  99                         wstream.Close ();
 100
 101                         // stream written
 102
 103                         req = WebRequest.Create (uri);
 104                         WebResponse res = req.GetResponse ();
 105
 106                         try {
 107                                 req.BeginGetRequestStream (null, null);
 108                                 Assertion.Fail ("#20: should've failed");
 109                         } catch (InvalidOperationException) {
 110                                 // Console.WriteLine ("20: " + e.Message + "\n" + e.StackTrace);
 111                                 // Cannot send a content-body with this verb-type
 112                         }
 113
 114                         try {
 115                                 req.Method = "PUT";
 116                                 req.BeginGetRequestStream (null, null);
 117                                 Assertion.Fail ("#21: should've failed");
 118                         } catch (InvalidOperationException) {
 119                                 // Console.WriteLine ("21: " + e.Message + "\n" + e.StackTrace);
 120                                 // This operation cannot be perfomed after the request has been submitted.
 121                         }
 122
 123                         try {
 124                                 //IAsyncResult async2 = req.BeginGetResponse (null, null);
 125                                 //Console.WriteLine ("OK!");
 126                                 req.GetResponse ();
 127                                 //Assertion.Fail ("#22: should've failed");
 128                         } catch (InvalidOperationException) {
 129                                 //Console.WriteLine ("22: " + e.Message + "\n" + e.StackTrace);
 130                                 // Cannot re-call BeginGetRequestStream/BeginGetResponse while
 131                                 // a previous call is still in progress
 132                                 Assertion.Fail ("#22: should not have failed");
 133                         }
 134
 135                         try {
 136                                 IAsyncResult async2 = req.BeginGetResponse (null, null);
 137
 138                                 // this succeeds !!
 139
 140                                 try {
 141                                         WebResponse res2 = req.EndGetResponse (async2);
 142
 143                                         // and this succeeds
 144
 145                                         Assertion.AssertEquals ("#23", res, res2) ;
 146
 147                                         //Assertion.Fail ("#23: should've failed");
 148                                 } catch (InvalidOperationException) {
 149                                         //Console.WriteLine ("22: " + e.Message + "\n" + e.StackTrace);
 150                                         // Cannot re-call BeginGetRequestStream/BeginGetResponse while
 151                                         // a previous call is still in progress
 152                                 }
 153
 154                                 // Assertion.Fail ("#22: should've failed");
 155                         } catch (InvalidOperationException) {
 156                         }
 157
 158                         Assertion.AssertEquals ("#2 len", (long) 5, res.ContentLength);
 159                         Assertion.AssertEquals ("#2 type", "binary/octet-stream", res.ContentType);
 160                         Assertion.AssertEquals ("#2 scheme", "file", res.ResponseUri.Scheme);
 161
 162                         Stream rstream = res.GetResponseStream ();
 163                         Assertion.AssertEquals ("#3r", true, rstream.CanRead);
 164                         Assertion.AssertEquals ("#3w", false, rstream.CanWrite);
 165                         Assertion.AssertEquals ("#3s", true, rstream.CanSeek);
 166
 167                         Assertion.AssertEquals ("#4a", 72, rstream.ReadByte ());
 168                         Assertion.AssertEquals ("#4b", 101, rstream.ReadByte ());
 169                         Assertion.AssertEquals ("#4c", 108, rstream.ReadByte ());
 170
 171                         rstream.Close ();
 172                         // res.Close ();
 173
 174                         try {
 175                                 long len = res.ContentLength;
 176                                 Assertion.AssertEquals ("#5", (long) 5, len);
 177                         } catch (ObjectDisposedException) {
 178                                 Assertion.Fail ("#disposed contentlength");
 179                         }
 180                         try {
 181                                 WebHeaderCollection w = res.Headers;
 182                         } catch (ObjectDisposedException) {
 183                                 Assertion.Fail ("#disposed headers");
 184                         }
 185                         try {
 186                                 res.Close ();
 187                         } catch (ObjectDisposedException) {
 188                                 Assertion.Fail ("#disposed close");
 189                         }
 190                 } catch (Exception) {
 191                         // Console.WriteLine ("ERROR! : " + ee.Message + "\n" + ee.StackTrace);
 192                 } finally {
 193                         try {
 194                                 // known bug #24940
 195                                 File.Delete (tmpFilename);
 196                         } catch (Exception) {
 197                                 // Console.WriteLine ("ERROR2! : " + ee2.Message + "\n" + ee2.StackTrace);
 198                         }
 199                 }
 200         }
 201
 202         [Test]
 203         public void Sync ()
 204         {
 205                 string tmpFilename = GetFilename ();
 206                 if (tmpFilename == null)
 207                         return;
 208
 209                 try {
 210                         if (File.Exists (tmpFilename))
 211                                 File.Delete (tmpFilename);
 212
 213                         Uri uri = new Uri ("file:///" + tmpFilename);
 214
 215                         WebRequest req = WebRequest.Create (uri);
 216
 217                         try {
 218                                 Stream stream = req.GetRequestStream ();
 219                                 Assertion.Fail ("should throw exception");
 220                         } catch (ProtocolViolationException) {}
 221
 222                         req.Method = "PUT";
 223
 224                         Stream wstream = req.GetRequestStream ();
 225                         Assertion.AssertEquals ("#1r", false, wstream.CanRead);
 226                         Assertion.AssertEquals ("#1w", true, wstream.CanWrite);
 227                         Assertion.AssertEquals ("#1s", true, wstream.CanSeek);
 228
 229                         wstream.WriteByte (72);
 230                         wstream.WriteByte (101);
 231                         wstream.WriteByte (108);
 232                         wstream.WriteByte (108);
 233                         wstream.WriteByte (111);
 234                         wstream.Close ();
 235
 236                         // stream written
 237
 238                         req = WebRequest.Create (uri);
 239                         WebResponse res = req.GetResponse ();
 240                         Assertion.AssertEquals ("#2 len", (long) 5, res.ContentLength);
 241                         Assertion.AssertEquals ("#2 type", "binary/octet-stream", res.ContentType);
 242                         Assertion.AssertEquals ("#2 scheme", "file", res.ResponseUri.Scheme);
 243
 244                         Stream rstream = res.GetResponseStream ();
 245                         Assertion.AssertEquals ("#3r", true, rstream.CanRead);
 246                         Assertion.AssertEquals ("#3w", false, rstream.CanWrite);
 247                         Assertion.AssertEquals ("#3s", true, rstream.CanSeek);
 248
 249                         Assertion.AssertEquals ("#4a", 72, rstream.ReadByte ());
 250                         Assertion.AssertEquals ("#4b", 101, rstream.ReadByte ());
 251                         Assertion.AssertEquals ("#4c", 108, rstream.ReadByte ());
 252
 253                         rstream.Close ();
 254                         // res.Close ();
 255
 256                         try {
 257                                 long len = res.ContentLength;
 258                                 Assertion.AssertEquals ("#5", (long) 5, len);
 259                         } catch (ObjectDisposedException) {
 260                                 Assertion.Fail ("#disposed contentlength");
 261                         }
 262                         try {
 263                                 WebHeaderCollection w = res.Headers;
 264                         } catch (ObjectDisposedException) {
 265                                 Assertion.Fail ("#disposed headers");
 266                         }
 267                         try {
 268                                 res.Close ();
 269                         } catch (ObjectDisposedException) {
 270                                 Assertion.Fail ("#disposed close");
 271                         }
 272
 273                 } finally {
 274                         try {
 275                                 File.Delete (tmpFilename);
 276                         } catch (Exception) { }
 277                 }
 278         }
 279
 280         private string GetFilename ()
 281         {
 282                 string tmpdir = Environment.GetEnvironmentVariable ("TMPDIR");
 283                 if (tmpdir == null || tmpdir.Length == 0) {
 284                         return null;
 285                 }
 286
 287                 tmpdir = tmpdir.Replace ('\\', '/');
 288                 if (tmpdir [tmpdir.Length - 1] != '/')
 289                         tmpdir += "/";
 290                 return tmpdir + "FileWebRequestTest.tmp";
 291         }
 292 }
 293
 294 }