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 class Test
  14 {
  15         static Func<T[]> For<T> (List<T> list)
  16         {
  17                 T [] t = new T [2];
  18                 return () => {
  19                         for (int i = 0; i < t.Length; ++i) {
  20                                 t [i] = list [i];
  21                         }
  22
  23                         return t;
  24                 };
  25         }
  26
  27         static Func<T> Throw<T> (T t)
  28         {
  29                 T l = t;
  30                 return () => {
  31                         throw new ApplicationException (l.ToString ());
  32                 };
  33         }
  34
  35         static Func<T> Do<T> (T t)
  36         {
  37                 T l = t;
  38                 return () => {
  39                         T t2;
  40                         do {
  41                                 t2 = l;
  42                         } while (default (T) != null);
  43
  44                         return t2;
  45                 };
  46         }
  47
  48         static Func<T> Lock<T> (T t)
  49         {
  50                 T l = t;
  51                 return () => {
  52                         lock (l.GetType ())
  53                         {
  54                                 l = default (T);
  55                                 return l;
  56                         }
  57                 };
  58         }
  59
  60         static Func<T> Catch<T> (T t)
  61         {
  62                 T l = t;
  63                 return () => {
  64                         try {
  65                                 throw new ApplicationException (l.ToString ());
  66                         } catch {
  67                                 return l;
  68                         }
  69                 };
  70         }
  71
  72         static Func<T> Finally<T> (T t)
  73         {
  74                 T l = t;
  75                 return () => {
  76                         try {
  77                                 l = Lock (l)();
  78                         } finally {
  79                                 l = default (T);
  80                         }
  81
  82                         return l;
  83                 };
  84         }
  85
  86         static Func<T> Using<T> (T t)
  87         {
  88                 T l = t;
  89                 using (var d = new Disposable<T> ())
  90                 {
  91                         return () => {
  92                                 return l;
  93                         };
  94                 }
  95         }
  96
  97         static Func<T> Switch<T> (T t)
  98         {
  99                 T l = t;
 100                 int? i = 0;
 101                 return () => {
 102                         switch (i) {
 103                                 default: return l;
 104                         }
 105                 };
 106         }
 107
 108         static Func<List<T>> ForForeach<T> (T[] t)
 109         {
 110                 return () => {
 111                         foreach (T e in t)
 112                                 return new List<T> () { e };
 113
 114                         throw new ApplicationException ();
 115                 };
 116         }
 117
 118         public void ArrayMutate<T> (T[] array)
 119         {
 120                 int r = 4;
 121                 Action<int> anonMeth = delegate (int slc) {
 122                         long[] idx = new long[] { 0, 0 };
 123                         for (int i = 0; i < r; i++) {
 124                                 idx [0] = i;
 125                         }
 126                 };
 127         }
 128
 129         static Func<T[][]> ArrayMultiMutate<T> (T[][] array)
 130         {
 131                 return () => {
 132                         for (int i = 0; i < 3; i++) {
 133                                 array [i][i] = default (T);
 134                         }
 135
 136                         return array;
 137                 };
 138         }
 139
 140         public static int Main ()
 141         {
 142                 if (For (new List<int> { 5, 10 })() [1] != 10)
 143                         return 1;
 144
 145                 var t = Throw (5);
 146                 try {
 147                         t ();
 148                         return 2;
 149                 } catch (ApplicationException)
 150                 {
 151                 }
 152
 153                 var t3 = Do ("rr");
 154                 if (t3 () != "rr")
 155                         return 3;
 156
 157                 var t4 = Lock ('f');
 158                 if (t4 () != '\0')
 159                         return 4;
 160
 161                 var t5 = Catch (3);
 162                 if (t5 () != 3)
 163                         return 5;
 164
 165                 var t6 = Finally (5);
 166                 if (t6 () != 0)
 167                         return 6;
 168
 169                 var t7 = Using (1.1);
 170                 if (t7 () != 1.1)
 171                         return 7;
 172
 173                 var t8 = Switch (55);
 174                 if (t8 () != 55)
 175                         return 8;
 176
 177                 var t9 = ForForeach (new [] { 4, 1 });
 178                 if (t9 ()[0] != 4)
 179                         return 9;
 180
 181                 var t10 = ArrayMultiMutate (new string [][] { new string [] { "a", "b", "c" }, new string [] { "1", "2", "3" }, new string [] { "A", "B", "C" }});
 182                 if (t10 () [2] [2] != null)
 183                         return 10;
 184
 185                 Console.WriteLine ("OK");
 186                 return 0;
 187         }
 188 }