mono/tests/appdomain-thread-abort.cs

   1 using System;
   2 using System.Threading;
   3 using System.Runtime.Remoting;
   4 using System.Reflection;
   5
   6 public class JustSomeClass {
   7 }
   8
   9 public class Test2 : ContextBoundObject
  10 {
  11         public void Run () {
  12                 Thread.CurrentThread.Abort ();
  13         }
  14 }
  15
  16 public class Test1 : MarshalByRefObject
  17 {
  18         public bool Run () {
  19                 AppDomain d = AppDomain.CreateDomain ("foo2");
  20
  21                 var t2 = (Test2)d.CreateInstanceAndUnwrap (Assembly.GetExecutingAssembly().FullName, "Test2");
  22                 try {
  23                         t2.Run ();
  24                 } catch (ThreadAbortException ex) {
  25                         Thread.ResetAbort ();
  26                         return true;
  27                 }
  28
  29                 return false;
  30         }
  31 }
  32
  33 public class Test : MarshalByRefObject {
  34         ThreadAbortException exc;
  35         public JustSomeClass other;
  36
  37         public void doThrow (int n, object state) {
  38                 if (n <= 0)
  39                         Thread.CurrentThread.Abort (state);
  40                 else
  41                         doThrow (n - 1, state);
  42         }
  43
  44         public void abortProxy () {
  45                 doThrow (10, this);
  46         }
  47
  48         public void abortOther () {
  49                 other = new JustSomeClass ();
  50                 doThrow (10, other);
  51         }
  52
  53         public void abortString () {
  54                 try {
  55                         doThrow (10, "bla");
  56                 } catch (ThreadAbortException e) {
  57                         exc = e;
  58                 }
  59         }
  60
  61         public void abortOtherIndirect (Test test) {
  62                 test.abortOther ();
  63         }
  64
  65         public object getState () {
  66                 return exc.ExceptionState;
  67         }
  68
  69         public int getInt () {
  70                 return 123;
  71         }
  72 }
  73
  74 public static class Tests
  75 {
  76         static AppDomain domain = AppDomain.CreateDomain ("newdomain");
  77
  78         public static int test_0_abort_other_indirect ()
  79         {
  80                 Test test = (Test) domain.CreateInstanceAndUnwrap (typeof (Test).Assembly.FullName, typeof (Test).FullName);
  81                 Test testHere = new Test ();
  82
  83                 if (!RemotingServices.IsTransparentProxy (test)) {
  84                         Console.WriteLine ("test is no proxy");
  85                         return 1;
  86                 }
  87
  88                 try {
  89                         test.abortOtherIndirect (testHere);
  90                 } catch (ThreadAbortException e) {
  91                         object state = e.ExceptionState;
  92                         Thread.ResetAbort ();
  93                         if ((JustSomeClass)state != testHere.other) {
  94                                 Console.WriteLine ("other class not preserved in state");
  95                                 return 2;
  96                         }
  97                 }
  98
  99                 return 0;
 100         }
 101
 102         public static int test_0_abort_string ()
 103         {
 104                 Test test = (Test) domain.CreateInstanceAndUnwrap (typeof (Test).Assembly.FullName, typeof (Test).FullName);
 105
 106                 if (!RemotingServices.IsTransparentProxy (test)) {
 107                         Console.WriteLine ("test is no proxy");
 108                         return 1;
 109                 }
 110
 111                 try {
 112                         test.abortString ();
 113                         Console.WriteLine ("no abort");
 114                         return 2;
 115                 } catch (ThreadAbortException e) {
 116                         object state;
 117                         state = e.ExceptionState;
 118                         Thread.ResetAbort ();
 119                         if (state == null) {
 120                                 Console.WriteLine ("state is null");
 121                                 return 3;
 122                         } else {
 123                                 if (RemotingServices.IsTransparentProxy (state)) {
 124                                         Console.WriteLine ("state is proxy");
 125                                         return 4;
 126                                 }
 127                                 if (!((string)state).Equals ("bla")) {
 128                                         Console.WriteLine ("state is wrong: " + (string)state);
 129                                         return 5;
 130                                 }
 131                         }
 132                         if (RemotingServices.IsTransparentProxy (e)) {
 133                                 Console.WriteLine ("exception is proxy");
 134                                 return 6;
 135                         }
 136                         if (test.getState () != null) {
 137                                 Console.WriteLine ("have state");
 138                                 return 7;
 139                         }
 140                 }
 141
 142                 return 0;
 143         }
 144
 145         public static int test_0_abort_proxy ()
 146         {
 147                 Test test = (Test) domain.CreateInstanceAndUnwrap (typeof (Test).Assembly.FullName, typeof (Test).FullName);
 148
 149                 if (!RemotingServices.IsTransparentProxy (test)) {
 150                         Console.WriteLine ("test is no proxy");
 151                         return 1;
 152                 }
 153
 154                 try {
 155                         test.abortProxy ();
 156                         Console.WriteLine ("no abort");
 157                         return 2;
 158                 } catch (ThreadAbortException e) {
 159                         object state;
 160                         state = e.ExceptionState;
 161                         Thread.ResetAbort ();
 162                         if (state == null) {
 163                                 Console.WriteLine ("state is null");
 164                                 return 3;
 165                         } else {
 166                                 if (!RemotingServices.IsTransparentProxy (state)) {
 167                                         Console.WriteLine ("state is not proxy");
 168                                         return 4;
 169                                 }
 170                                 if (((Test)state).getInt () != 123) {
 171                                         Console.WriteLine ("state doesn't work");
 172                                         return 5;
 173                                 }
 174                         }
 175                         if (RemotingServices.IsTransparentProxy (e)) {
 176                                 Console.WriteLine ("exception is proxy");
 177                                 return 6;
 178                         }
 179                 }
 180
 181                 return 0;
 182         }
 183
 184         public static int test_0_abort_other ()
 185         {
 186                 Test test = (Test) domain.CreateInstanceAndUnwrap (typeof (Test).Assembly.FullName, typeof (Test).FullName);
 187
 188                 if (!RemotingServices.IsTransparentProxy (test)) {
 189                         Console.WriteLine ("test is no proxy");
 190                         return 1;
 191                 }
 192
 193                 try {
 194                         test.abortOther ();
 195                         Console.WriteLine ("no abort");
 196                         return 2;
 197                 } catch (ThreadAbortException e) {
 198                         object state = null;
 199                         bool stateExc = false;
 200
 201                         try {
 202                                 state = e.ExceptionState;
 203                                 Console.WriteLine ("have state");
 204                         } catch (Exception) {
 205                                 stateExc = true;
 206                                 /* FIXME: if we put this after the try/catch, mono
 207                                    quietly quits */
 208                                 Thread.ResetAbort ();
 209                         }
 210                         if (!stateExc) {
 211                                 Console.WriteLine ("no state exception");
 212                                 return 3;
 213                         }
 214
 215                         if (RemotingServices.IsTransparentProxy (e)) {
 216                                 Console.WriteLine ("exception is proxy");
 217                                 return 4;
 218                         }
 219                 }
 220
 221                 return 0;
 222         }
 223
 224         public static int test_0_abort_in_thread ()
 225         {
 226                 // #539394
 227                 // Calling Thread.Abort () from a remoting call throws a ThreadAbortException which
 228                 // cannot be caught because the exception handling code is confused by the domain
 229                 // transitions
 230                 bool res = false;
 231
 232                 Thread thread = new Thread (delegate () {
 233                         AppDomain d = AppDomain.CreateDomain ("foo");
 234
 235                         var t = (Test1)d.CreateInstanceAndUnwrap (Assembly.GetExecutingAssembly().FullName, "Test1");
 236                         res = t.Run ();
 237                 });
 238
 239                 thread.Start ();
 240                 thread.Join ();
 241
 242                 if (!res)
 243                         return 1;
 244
 245                 return 0;
 246         }
 247
 248         public static int Main (string [] args)
 249         {
 250                 return TestDriver.RunTests (typeof (Tests), args);
 251         }
 252 }