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

   1 //
   2 // System.Net.WebClientTestAsync
   3 //
   4 // Authors:
   5 //      Martin Baulig (martin.baulig@googlemail.com)
   6 //
   7 // Copyright 2012 Xamarin Inc. (http://www.xamarin.com)
   8 //
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29 #if NET_4_5
  30 using System;
  31 using System.IO;
  32 using System.Collections.Generic;
  33 using System.Threading;
  34 using System.Threading.Tasks;
  35 using System.Reflection;
  36 using System.Net;
  37 using NUnit.Framework;
  38
  39 namespace MonoTests.System.Net
  40 {
  41         [TestFixture]
  42         public class WebClientTestAsync
  43         {
  44                 [Test]
  45                 [Category("Async")]
  46                 [Category("AndroidNotWorking")] // Attempts to access the test dll which won't work on Android
  47                 public void DownloadData ()
  48                 {
  49                         WebClient wc;
  50                         bool progress_changed = false;
  51                         bool completed = false;
  52                         bool progress_changed_error = false;
  53                         bool completed_error = false;
  54
  55                         int thread_id = Thread.CurrentThread.ManagedThreadId;
  56
  57                         wc = new WebClient ();
  58
  59                         wc.DownloadProgressChanged += delegate {
  60                                 progress_changed = true;
  61                                 if (Thread.CurrentThread.ManagedThreadId != thread_id)
  62                                         progress_changed_error = true;
  63                         };
  64                         wc.DownloadDataCompleted += delegate {
  65                                 completed = true;
  66                                 if (Thread.CurrentThread.ManagedThreadId != thread_id)
  67                                         completed_error = true;
  68                         };
  69
  70                         MessagePumpSyncContext.Run (async () => {
  71                                 var url = Assembly.GetExecutingAssembly ().CodeBase;
  72                                 await wc.DownloadDataTaskAsync (url);
  73                                 Assert.AreEqual (Thread.CurrentThread.ManagedThreadId, thread_id);
  74                         }, () => progress_changed && completed, 10000);
  75
  76                         Assert.IsTrue (progress_changed, "#1");
  77                         Assert.IsFalse (progress_changed_error, "#2");
  78                         Assert.IsTrue (completed, "#3");
  79                         Assert.IsFalse (completed_error, "#4");
  80                 }
  81
  82                 [Test]
  83                 [Category("InetAccess")]
  84                 public void DownloadFileTaskAsync ()
  85                 {
  86                         WebClient wc = new WebClient ();
  87                         string filename = Path.GetTempFileName ();
  88
  89                         var task = wc.DownloadFileTaskAsync ("http://www.mono-project.com/", filename);
  90                         Assert.IsTrue (task.Wait (15000));
  91                         Assert.IsTrue (task.IsCompleted);
  92
  93                         File.Delete (filename);
  94                 }
  95
  96                 [Test]
  97                 [Category("InetAccess")]
  98                 public void Cancellation ()
  99                 {
 100                         WebClient wc = new WebClient ();
 101                         var progress = new ManualResetEvent (false);
 102                         wc.DownloadProgressChanged += delegate {
 103                                 progress.Set ();
 104                         };
 105
 106                         // Try downloading some large file, so we don't finish early.
 107                         var url = "http://download.mono-project.com/archive/2.10.9/macos-10-x86/11/MonoFramework-MDK-2.10.9_11.macos10.xamarin.x86.dmg";
 108                         var task = wc.DownloadDataTaskAsync (url);
 109                         Assert.IsTrue (progress.WaitOne (15000), "#1");
 110                         wc.CancelAsync ();
 111
 112                         try {
 113                                 task.Wait ();
 114                                 Assert.Fail ("#2");
 115                         } catch (Exception ex) {
 116                                 if (ex is AggregateException)
 117                                         ex = ((AggregateException)ex).InnerException;
 118                                 Assert.That (ex is WebException || ex is OperationCanceledException, "#4");
 119                                 Assert.IsTrue (task.IsCanceled || task.IsFaulted, "#5");
 120                         }
 121                 }
 122
 123                 [Test]
 124                 [Category("InetAccess")]
 125                 public void DownloadMultiple ()
 126                 {
 127                         WebClient wc = new WebClient ();
 128                         var t1 = wc.OpenReadTaskAsync ("http://www.google.com/");
 129                         Assert.That (t1.Wait (15000));
 130                         Assert.IsTrue (t1.IsCompleted, "#1");
 131
 132                         var t2 = wc.OpenReadTaskAsync ("http://www.mono-project.com/");
 133                         Assert.That (t2.Wait (15000));
 134                         Assert.IsTrue (t2.IsCompleted, "#2");
 135
 136                         var t3 = wc.DownloadStringTaskAsync ("http://www.google.com/");
 137                         Assert.That (t3.Wait (15000));
 138                         Assert.IsTrue (t3.IsCompleted, "#3");
 139                 }
 140
 141                 [Test]
 142                 [Category("InetAccess")]
 143                 public void DownloadMultiple2 ()
 144                 {
 145                         WebClient wc = new WebClient ();
 146
 147                         MessagePumpSyncContext.Run (async () => {
 148                                 await wc.DownloadStringTaskAsync ("http://www.google.com/");
 149                                 await wc.DownloadDataTaskAsync ("http://www.mono-project.com/");
 150                         }, null, 15000);
 151                 }
 152
 153                 [Test]
 154                 [Category("InetAccess")]
 155                 public void DownloadMultiple3 ()
 156                 {
 157                         WebClient wc = new WebClient ();
 158                         int thread_id = Thread.CurrentThread.ManagedThreadId;
 159                         bool data_completed = false;
 160                         bool string_completed = false;
 161                         bool error = false;
 162
 163                         wc.DownloadDataCompleted += delegate {
 164                                 if (data_completed || (Thread.CurrentThread.ManagedThreadId != thread_id))
 165                                         error = true;
 166                                 data_completed = true;
 167                         };
 168                         wc.DownloadStringCompleted += delegate {
 169                                 if (string_completed || (Thread.CurrentThread.ManagedThreadId != thread_id))
 170                                         error = true;
 171                                 string_completed = true;
 172                         };
 173
 174                         MessagePumpSyncContext.Run (async () => {
 175                                 await wc.DownloadStringTaskAsync ("http://www.google.com/");
 176                                 await wc.DownloadDataTaskAsync ("http://www.mono-project.com/");
 177                         }, () => data_completed && string_completed, 15000);
 178
 179                         Assert.IsTrue (data_completed, "#1");
 180                         Assert.IsTrue (string_completed, "#2");
 181                         Assert.IsFalse (error, "#3");
 182                 }
 183
 184                 public sealed class MessagePumpSyncContext : SynchronizationContext
 185                 {
 186                         private delegate void MyAction ();
 187
 188                         private readonly Queue<MyAction> queue = new Queue<MyAction> ();
 189                         private readonly object sync = new object ();
 190                         private readonly Func<bool> completed;
 191                         private readonly int timeout;
 192                         private bool running = true;
 193
 194                         MessagePumpSyncContext (Func<bool> completed, int timeout)
 195                         {
 196                                 this.completed = completed;
 197                                 this.timeout = timeout;
 198                         }
 199
 200                         public override void Send (SendOrPostCallback d, object state)
 201                         {
 202                                 throw new InvalidOperationException ();
 203                         }
 204
 205                         public override void Post (SendOrPostCallback d, object state)
 206                         {
 207                                 lock (sync) {
 208                                         queue.Enqueue (() => d (state));
 209                                         Monitor.Pulse (sync);
 210                                 }
 211                         }
 212
 213                         bool IsCompleted {
 214                                 get {
 215                                         if (running)
 216                                                 return false;
 217                                         if (completed != null)
 218                                                 return completed ();
 219                                         return true;
 220                                 }
 221                         }
 222
 223                         void RunMessagePump ()
 224                         {
 225                                 while (running) {
 226                                         MyAction action;
 227                                         lock (sync) {
 228                                                 while (queue.Count == 0) {
 229                                                         if (IsCompleted)
 230                                                                 return;
 231                                                         if (!Monitor.Wait (sync, timeout))
 232                                                                 throw new TimeoutException ();
 233                                                 }
 234                                                 action = queue.Dequeue ();
 235                                         }
 236                                         action ();
 237                                 }
 238                         }
 239
 240                         public void Cancel ()
 241                         {
 242                                 lock (sync) {
 243                                         running = false;
 244                                         Monitor.Pulse (sync);
 245                                 }
 246                         }
 247
 248                         public static void Run (Func<Task> action, Func<bool> completed, int timeout)
 249                         {
 250                                 var old_ctx = SynchronizationContext.Current;
 251
 252                                 var ctx = new MessagePumpSyncContext (completed, timeout);
 253                                 try {
 254                                         SynchronizationContext.SetSynchronizationContext (ctx);
 255
 256                                         var thread_id = Thread.CurrentThread.ManagedThreadId;
 257
 258                                         var task = action ();
 259                                         task.ContinueWith ((t) => {
 260                                                 ctx.running = false;
 261                                         }, TaskScheduler.FromCurrentSynchronizationContext ());
 262
 263                                         ctx.RunMessagePump ();
 264
 265                                         if (task.IsFaulted)
 266                                                 throw task.Exception;
 267                                 } finally {
 268                                         SynchronizationContext.SetSynchronizationContext (old_ctx);
 269                                 }
 270                         }
 271
 272                 }
 273         }
 274 }
 275 #endif