mono/tests/thread6.cs

   1 //
   2 // thread6.cs: Thread abort tests
   3 //
   4 using System;
   5 using System.Threading;
   6
   7 public class Tests {
   8
   9         public static int result = 0;
  10         public static object started = new object ();
  11
  12         public static void ThreadStart1 () {
  13                 Console.WriteLine("{0} started",
  14                                   Thread.CurrentThread.Name);
  15
  16                 try {
  17                         try {
  18                                 try {
  19                                         lock (started) {
  20                                                 Monitor.Pulse (started);
  21                                         }
  22                                         int i = 0;
  23                                         try {
  24                                                 while (true) {
  25                                                         Console.WriteLine ("Count: " + i++);
  26                                                         Thread.Sleep (100);
  27                                                 }
  28                                         }
  29                                         catch (ThreadAbortException e) {
  30                                                 Console.WriteLine ("cought exception level 3 ");
  31
  32                                                 // Check that the exception is only rethrown in
  33                                                 // the appropriate catch clauses
  34
  35                                                 // This doesn't work currently, see
  36                                                 // http://bugzilla.ximian.com/show_bug.cgi?id=68552
  37
  38                                                 /*
  39                                                 try {
  40                                                 }
  41                                                 catch {}
  42                                                 try {
  43                                                         throw new DivideByZeroException ();
  44                                                 }
  45                                                 catch (Exception) {
  46                                                 }
  47                                                 */
  48                                                 result |= 32;
  49
  50                                                 // Check that the exception is properly rethrown
  51                                         }
  52                                         result = 255;
  53                                 } catch (ThreadAbortException e) {
  54                                         Console.WriteLine ("cought exception level 2 " + e.ExceptionState);
  55                                         Console.WriteLine (e);
  56                                         if ((string)e.ExceptionState == "STATETEST")
  57                                                 result |= 1;
  58
  59                                         Thread.ResetAbort ();
  60                                         throw e;
  61                                 }
  62                         } catch (ThreadAbortException e) {
  63                                 Console.WriteLine ("cought exception level 1 " + e.ExceptionState);
  64                                 Console.WriteLine (e);
  65                                 if (e.ExceptionState == null)
  66                                         result |= 2;
  67                         }
  68                 } catch (Exception e) {
  69                         Console.WriteLine ("cought exception level 0")
  70 ;                       Console.WriteLine (e);
  71                         Console.WriteLine (e.StackTrace);
  72                         result |= 4;
  73                 }
  74
  75                 try {
  76                         Thread.ResetAbort ();
  77                 } catch (System.Threading.ThreadStateException e) {
  78                         result |= 8;
  79                 }
  80
  81                 Console.WriteLine ("end");
  82                 result |= 16;
  83         }
  84
  85         static string regress_78024 ()
  86         {
  87                 try {
  88                         Thread.CurrentThread.Abort ();
  89                 } catch (Exception e) {
  90                         return "Got exception: " + e.Message;
  91                 } finally {
  92                 }
  93                 return "";
  94         }
  95
  96         public static int Main() {
  97                 return TestDriver.RunTests (typeof (Tests));
  98         }
  99
 100         public static int test_0_abort_current () {
 101                 // Check aborting the current thread
 102                 bool aborted = false;
 103                 try {
 104                         Thread.CurrentThread.Abort ();
 105                 }
 106                 catch {
 107                         aborted = true;
 108                         Thread.ResetAbort ();
 109                 }
 110                 if (!aborted)
 111                         return 2;
 112
 113                 return 0;
 114         }
 115
 116         public static int test_0_test_1 () {
 117                 Thread t1 = null;
 118
 119                 lock (started) {
 120                         t1 = new Thread(new ThreadStart
 121                                                         (Tests.ThreadStart1));
 122                         t1.Name = "Thread 1";
 123
 124                         Thread.Sleep (100);
 125
 126                         t1.Start();
 127
 128                         Monitor.Wait (started);
 129                 }
 130
 131                 Thread.Sleep (100);
 132
 133                 t1.Abort ("STATETEST");
 134
 135                 t1.Join ();
 136
 137                 if (result != 59) {
 138                         Console.WriteLine ("Result: " + result);
 139                         return 1;
 140                 }
 141
 142                 return 0;
 143         }
 144
 145         public static int test_0_regress_68552 () {
 146                 try {
 147                         try {
 148                                 Run ();
 149                         } catch (Exception ex) {
 150                         }
 151
 152                         return 2;
 153                 }
 154                 catch (ThreadAbortException ex) {
 155                         Thread.ResetAbort ();
 156                 }
 157
 158                 return 0;
 159         }
 160
 161         public static int test_0_regress_78024 () {
 162                 try {
 163                         regress_78024 ();
 164                         return 3;
 165                 }
 166                 catch (ThreadAbortException ex) {
 167                         Thread.ResetAbort ();
 168                 }
 169
 170                 return 0;
 171         }
 172
 173         public class CBO : ContextBoundObject {
 174                 public void Run () {
 175                         Thread.CurrentThread.Abort ("FOO");
 176                 }
 177         }
 178
 179         public static int test_0_regress_539394 () {
 180                 // Check that a ThreadAbortException thrown through remoting retains its
 181                 // abort state
 182                 AppDomain d = AppDomain.CreateDomain ("test");
 183                 CBO obj = (CBO)d.CreateInstanceFromAndUnwrap (typeof (Tests).Assembly.Location, "Tests/CBO");
 184                 bool success = false;
 185
 186                 Thread t = new Thread (delegate () {
 187                                 try {
 188                                         obj.Run ();
 189                                 } catch (ThreadAbortException ex) {
 190                                         if ((string)ex.ExceptionState == "FOO")
 191                                                 success = true;
 192                                 }
 193                         });
 194
 195                 t.Start ();
 196                 t.Join ();
 197
 198                 return success ? 0 : 1;
 199         }
 200
 201         public static int test_0_regress_4413 () {
 202                 // Check that thread abort exceptions originating in another thread are not automatically rethrown
 203                 object o = new object ();
 204                 Thread t = null;
 205                 Action a = delegate () {
 206                         t = Thread.CurrentThread;
 207                         lock (o) {
 208                                 Monitor.Pulse (o);
 209                         }
 210                         while (true) {
 211                                 Thread.Sleep (1000);
 212                         }
 213                 };
 214                 var ar = a.BeginInvoke (null, null);
 215                 lock (o) {
 216                         Monitor.Wait (o);
 217                 }
 218
 219                 t.Abort ();
 220
 221                 try {
 222                         try {
 223                                 a.EndInvoke (ar);
 224                         } catch (ThreadAbortException) {
 225                         }
 226                 } catch (ThreadAbortException) {
 227                         // This will fail
 228                         Thread.ResetAbort ();
 229                         return 1;
 230                 }
 231
 232                 return 0;
 233         }
 234
 235         public static void Run ()
 236         {
 237                 try {
 238                         Thread.CurrentThread.Abort ();
 239                 } catch (Exception ex) {
 240                         throw new Exception ("other");
 241                 }
 242         }
 243 }
 244