mono/tests/synchronized.cs

   1 //
   2 //  synchronized.cs:
   3 //
   4 //    Tests for the 'synchronized' method attribute
   5 //
   6
   7 using System;
   8 using System.Threading;
   9 using System.Runtime.CompilerServices;
  10
  11 class Tests {
  12
  13         // We use Monitor.Pulse to test that the object is synchronized
  14
  15         [MethodImplAttribute(MethodImplOptions.Synchronized)]
  16         public int test () {
  17                 Monitor.Pulse (this);
  18                 //Monitor.Enter (this);
  19                 return 2 + 2;
  20         }
  21
  22         [MethodImplAttribute(MethodImplOptions.Synchronized)]
  23         public static int test_static () {
  24                 Monitor.Pulse (typeof (Tests));
  25                 return 2 + 2;
  26         }
  27
  28         [MethodImplAttribute(MethodImplOptions.Synchronized)]
  29         public int test_exception () {
  30                 Monitor.Exit (this);
  31                 throw new Exception ("A");
  32         }
  33
  34         [MethodImplAttribute(MethodImplOptions.Synchronized)]
  35         public virtual int test_virtual () {
  36                 Monitor.Pulse (this);
  37                 return 2 + 2;
  38         }
  39
  40         public static bool is_synchronized (object o) {
  41                 try {
  42                         Monitor.Pulse (o);
  43                 }
  44                 catch (SynchronizationLockException ex) {
  45                         return false;
  46                 }
  47                 return true;
  48         }
  49
  50         class Gen<T>
  51         {
  52                 [MethodImpl(MethodImplOptions.Synchronized)]
  53                 public static void Run ()
  54                 {
  55                 }
  56         }
  57
  58         public delegate int Delegate1 ();
  59
  60         static public int Main (String[] args) {
  61                 Tests b = new Tests ();
  62                 int res, err;
  63
  64                 Console.WriteLine ("Test1...");
  65                 b.test ();
  66                 if (is_synchronized (b))
  67                         return 1;
  68
  69                 Console.WriteLine ("Test2...");
  70                 test_static ();
  71                 if (is_synchronized (typeof (Tests)))
  72                         return 1;
  73
  74                 Console.WriteLine ("Test3...");
  75                 try {
  76                         b.test_exception ();
  77                 }
  78                 catch (SynchronizationLockException ex) {
  79                         // OK
  80                 }
  81                 catch (Exception ex) {
  82                         // The other exception should be overwritten by the lock one
  83                         return 1;
  84                 }
  85                 if (is_synchronized (b))
  86                         return 1;
  87
  88                 Console.WriteLine ("Test4...");
  89                 b.test_virtual ();
  90                 if (is_synchronized (b))
  91                         return 1;
  92
  93                 Console.WriteLine ("Test5...");
  94                 Delegate1 d = new Delegate1 (b.test);
  95                 res = d ();
  96                 if (is_synchronized (b))
  97                         return 1;
  98
  99                 Console.WriteLine ("Test6...");
 100                 d = new Delegate1 (test_static);
 101                 res = d ();
 102                 if (is_synchronized (typeof (Tests)))
 103                         return 1;
 104
 105                 Console.WriteLine ("Test7...");
 106                 d = new Delegate1 (b.test_virtual);
 107                 res = d ();
 108                 if (is_synchronized (b))
 109                         return 1;
 110
 111                 Console.WriteLine ("Test8...");
 112                 d = new Delegate1 (b.test_exception);
 113                 try {
 114                         d ();
 115                 }
 116                 catch (SynchronizationLockException ex) {
 117                         // OK
 118                 }
 119                 catch (Exception ex) {
 120                         return 2;
 121                 }
 122                 if (is_synchronized (b))
 123                         return 1;
 124
 125                 Monitor.Enter (typeof (Gen<>));
 126                 Thread t = new Thread (() =>
 127                         {
 128                                 Gen<object>.Run ();
 129                         });
 130                 t.Start ();
 131                 t.Join ();
 132                 Monitor.Exit (typeof (Gen<>));
 133
 134                 return 0;
 135         }
 136 }