mcs/tests/gtest-anon-24.cs

   1 using System;
   2 using System.Collections.Generic;
   3
   4 // Generics mutate tests
   5
   6 class Disposable<T> : IDisposable
   7 {
   8         public void Dispose ()
   9         {
  10         }
  11 }
  12
  13 interface IFoo<TOne,TTwo>
  14 {
  15 }
  16
  17 class CA<T>
  18 {
  19         public struct Nested
  20         {
  21                 public static readonly T Value;
  22                 public readonly T Value2;
  23         }
  24 }
  25
  26 class Test
  27 {
  28         static Func<T[]> For<T> (List<T> list)
  29         {
  30                 T [] t = new T [2];
  31                 return () => {
  32                         for (int i = 0; i < t.Length; ++i) {
  33                                 t [i] = list [i];
  34                         }
  35
  36                         return t;
  37                 };
  38         }
  39
  40         static Func<T> Throw<T> (T t)
  41         {
  42                 T l = t;
  43                 return () => {
  44                         throw new ApplicationException (l.ToString ());
  45                 };
  46         }
  47
  48         static Func<Type> TypeOf<T> (T t)
  49         {
  50                 T l = t;
  51                 return () => {
  52                         l = t;
  53                         var e = typeof (Disposable <T>);
  54                         e = typeof (Disposable <>);
  55                         e = typeof (IFoo <,>);
  56                         return typeof (T);
  57                 };
  58         }
  59
  60         static Func<T> Do<T> (T t)
  61         {
  62                 T l = t;
  63                 return () => {
  64                         T t2;
  65                         do {
  66                                 t2 = l;
  67                         } while (default (T) != null);
  68
  69                         return t2;
  70                 };
  71         }
  72
  73         static Func<T> Lock<T> (T t)
  74         {
  75                 T l = t;
  76                 return () => {
  77                         lock (l.GetType ())
  78                         {
  79                                 l = default (T);
  80                                 return l;
  81                         }
  82                 };
  83         }
  84
  85         static Func<T> Catch<T> (T t)
  86         {
  87                 T l = t;
  88                 return () => {
  89                         try {
  90                                 throw new ApplicationException (l.ToString ());
  91                         } catch {
  92                                 return l;
  93                         }
  94                 };
  95         }
  96
  97         static Func<T> Finally<T> (T t)
  98         {
  99                 T l = t;
 100                 return () => {
 101                         try {
 102                                 l = Lock (l)();
 103                         } finally {
 104                                 l = default (T);
 105                         }
 106
 107                         return l;
 108                 };
 109         }
 110
 111         static Func<T> Using<T> (T t)
 112         {
 113                 T l = t;
 114                 using (var d = new Disposable<T> ())
 115                 {
 116                         return () => {
 117                                 return l;
 118                         };
 119                 }
 120         }
 121
 122         static Func<T> Switch<T> (T t)
 123         {
 124                 T l = t;
 125                 int? i = 0;
 126                 return () => {
 127                         switch (i) {
 128                                 default: return l;
 129                         }
 130                 };
 131         }
 132
 133         static Func<List<T>> ForForeach<T> (T[] t)
 134         {
 135                 return () => {
 136                         foreach (T e in t)
 137                                 return new List<T> () { e };
 138
 139                         throw new ApplicationException ();
 140                 };
 141         }
 142
 143         public void ArrayMutate<T> (T[] array)
 144         {
 145                 int r = 4;
 146                 Action<int> anonMeth = delegate (int slc) {
 147                         long[] idx = new long[] { 0, 0 };
 148                         for (int i = 0; i < r; i++) {
 149                                 idx [0] = i;
 150                         }
 151                 };
 152         }
 153
 154         static Func<T[][]> ArrayMultiMutate<T> (T[][] array)
 155         {
 156                 return () => {
 157                         for (int i = 0; i < 3; i++) {
 158                                 array [i][i] = default (T);
 159                         }
 160
 161                         return array;
 162                 };
 163         }
 164
 165         static Func<T[]> NestedTypeMutate<T> ()
 166         {
 167                 var local = new CA<T>.Nested ();
 168                 return () => {
 169                         return new [] { CA<T>.Nested.Value, local.Value2 };
 170                 };
 171         }
 172
 173         public static int Main ()
 174         {
 175                 if (For (new List<int> { 5, 10 })() [1] != 10)
 176                         return 1;
 177
 178                 var t = Throw (5);
 179                 try {
 180                         t ();
 181                         return 2;
 182                 } catch (ApplicationException)
 183                 {
 184                 }
 185
 186                 var t3 = Do ("rr");
 187                 if (t3 () != "rr")
 188                         return 3;
 189
 190                 var t4 = Lock ('f');
 191                 if (t4 () != '\0')
 192                         return 4;
 193
 194                 var t5 = Catch (3);
 195                 if (t5 () != 3)
 196                         return 5;
 197
 198                 var t6 = Finally (5);
 199                 if (t6 () != 0)
 200                         return 6;
 201
 202                 var t7 = Using (1.1);
 203                 if (t7 () != 1.1)
 204                         return 7;
 205
 206                 var t8 = Switch (55);
 207                 if (t8 () != 55)
 208                         return 8;
 209
 210                 var t9 = ForForeach (new [] { 4, 1 });
 211                 if (t9 ()[0] != 4)
 212                         return 9;
 213
 214                 var t10 = ArrayMultiMutate (new string [][] { new string [] { "a", "b", "c" }, new string [] { "1", "2", "3" }, new string [] { "A", "B", "C" }});
 215                 if (t10 () [2] [2] != null)
 216                         return 10;
 217
 218                 var t11 = TypeOf ("b");
 219                 if (t11 () != typeof (string))
 220                         return 11;
 221
 222                 var t12 = NestedTypeMutate<ulong> ()();
 223                 if (t12 [0] != 0 || t12 [1] != 0)
 224                         return 12;
 225
 226                 Console.WriteLine ("OK");
 227                 return 0;
 228         }
 229 }