mcs/tests/gtest-284.cs

   1 using System;
   2 using System.Collections;
   3 using System.Collections.Generic;
   4
   5 public interface Y
   6 { }
   7
   8 public class X : Y
   9 {
  10 }
  11
  12 public struct Foo : Y
  13 { }
  14
  15 public static class CollectionTester
  16 {
  17         static int Test<T> (IList<T> list)
  18         {
  19                 if (list.Count != 1)
  20                         return 1;
  21
  22                 ICollection<T> collection = list;
  23                 if (collection.Count != 1)
  24                         return 2;
  25
  26                 IEnumerable<T> enumerable = list;
  27                 IEnumerator<T> enumerator = enumerable.GetEnumerator ();
  28                 if (!enumerator.MoveNext ())
  29                         return 3;
  30                 if (enumerator.MoveNext ())
  31                         return 4;
  32
  33                 return 0;
  34         }
  35
  36         public static int Test ()
  37         {
  38 #region X
  39                 X[] xarray = new X [] { new X () };
  40
  41                 int result;
  42                 result = Test<X> (xarray);
  43                 if (result != 0)
  44                         return result;
  45
  46                 result = Test<object> (xarray);
  47                 if (result != 0)
  48                         return 10 + result;
  49
  50                 result = Test<Y> (xarray);
  51                 if (result != 0)
  52                         return 20 + result;
  53 #endregion
  54
  55 #region int
  56                 int[] iarray = new int [] { 5 };
  57                 result = Test<int> (iarray);
  58                 if (result != 0)
  59                         return 30 + result;
  60
  61                 result = Test<uint> ((IList<uint>) (object) iarray);
  62                 if (result != 0)
  63                         return 40 + result;
  64
  65                 uint[] uiarray = new uint [] { 5 };
  66                 result = Test<int> ((IList<int>) (object) uiarray);
  67                 if (result != 0)
  68                         return 50 + result;
  69
  70                 result = Test<uint> (uiarray);
  71                 if (result != 0)
  72                         return 60 + result;
  73 #endregion
  74
  75 #region long
  76                 long[] larray = new long [] { 5 };
  77                 result = Test<long> (larray);
  78                 if (result != 0)
  79                         return 70 + result;
  80
  81                 result = Test<ulong> ((IList<ulong>) (object) larray);
  82                 if (result != 0)
  83                         return 80 + result;
  84
  85                 ulong[] ularray = new ulong [] { 5 };
  86                 result = Test<long> ((IList<long>) (object) ularray);
  87                 if (result != 0)
  88                         return 90 + result;
  89
  90                 result = Test<ulong> (ularray);
  91                 if (result != 0)
  92                         return 100 + result;
  93 #endregion
  94
  95 #region short
  96                 short[] sarray = new short [] { 5 };
  97                 result = Test<short> (sarray);
  98                 if (result != 0)
  99                         return 110 + result;
 100
 101                 result = Test<ushort> ((IList<ushort>) (object) sarray);
 102                 if (result != 0)
 103                         return 120 + result;
 104
 105                 ushort[] usarray = new ushort [] { 5 };
 106                 result = Test<short> ((IList<short>) (object) usarray);
 107                 if (result != 0)
 108                         return 130 + result;
 109
 110                 result = Test<ushort> (usarray);
 111                 if (result != 0)
 112                         return 140 + result;
 113 #endregion
 114
 115 #region byte
 116                 byte[] barray = new byte [] { 5 };
 117                 result = Test<byte> (barray);
 118                 if (result != 0)
 119                         return 150 + result;
 120
 121                 result = Test<sbyte> ((IList<sbyte>) (object) barray);
 122                 if (result != 0)
 123                         return 160 + result;
 124
 125                 sbyte[] sbarray = new sbyte [] { 5 };
 126                 result = Test<byte> ((IList<byte>) (object) sbarray);
 127                 if (result != 0)
 128                         return 170 + result;
 129
 130                 result = Test<sbyte> (sbarray);
 131                 if (result != 0)
 132                         return 180 + result;
 133 #endregion
 134
 135                 return 0;
 136         }
 137 }
 138
 139 public static class InterfaceTester
 140 {
 141         public const bool Debug = false;
 142
 143         static readonly Type ilist_type;
 144         static readonly Type icollection_type;
 145         static readonly Type ienumerable_type;
 146         static readonly Type generic_ilist_type;
 147         static readonly Type generic_icollection_type;
 148         static readonly Type generic_ienumerable_type;
 149         static readonly Type icloneable_type;
 150
 151         static InterfaceTester ()
 152         {
 153                 ilist_type = typeof (IList);
 154                 icollection_type = typeof (ICollection);
 155                 ienumerable_type = typeof (IEnumerable);
 156                 generic_ilist_type = typeof (IList<>);
 157                 generic_icollection_type = typeof (ICollection<>);
 158                 generic_ienumerable_type = typeof (IEnumerable<>);
 159                 icloneable_type = typeof (ICloneable);
 160         }
 161
 162         enum State {
 163                 Missing,
 164                 Found,
 165                 Extra
 166         }
 167
 168         static int Test (Type t, params Type[] iface_types)
 169         {
 170                 Hashtable ifaces = new Hashtable ();
 171                 ifaces.Add (ilist_type, State.Missing);
 172                 ifaces.Add (icollection_type, State.Missing);
 173                 ifaces.Add (ienumerable_type, State.Missing);
 174                 ifaces.Add (icloneable_type, State.Missing);
 175
 176                 Type array_type = t.MakeArrayType ();
 177
 178                 if (Debug) {
 179                         Console.WriteLine ("Checking {0}", t);
 180                         foreach (Type iface in t.GetInterfaces ())
 181                                 Console.WriteLine ("  {0}", iface);
 182                 }
 183
 184                 foreach (Type iface in iface_types) {
 185                         Type[] gargs = new Type[] { iface };
 186                         ifaces.Add (generic_ilist_type.MakeGenericType (gargs), State.Missing);
 187                         ifaces.Add (generic_icollection_type.MakeGenericType (gargs), State.Missing);
 188                         ifaces.Add (generic_ienumerable_type.MakeGenericType (gargs), State.Missing);
 189                 }
 190
 191                 foreach (Type iface in array_type.GetInterfaces ()) {
 192                         if (ifaces.Contains (iface))
 193                                 ifaces [iface] = State.Found;
 194                         else
 195                                 ifaces.Add (iface, State.Extra);
 196                 }
 197
 198                 int errors = 0;
 199
 200                 foreach (Type iface in ifaces.Keys) {
 201                         State state = (State) ifaces [iface];
 202                         if (state == State.Found) {
 203                                 if (Debug)
 204                                         Console.WriteLine ("Found {0}", iface);
 205                                 continue;
 206                         } else {
 207                                 if (Debug)
 208                                         Console.WriteLine ("ERROR: {0} {1}", iface, state);
 209                                 errors++;
 210                         }
 211                 }
 212
 213                 if (Debug)
 214                         Console.WriteLine ();
 215
 216                 return errors;
 217         }
 218
 219         public static int Test ()
 220         {
 221                 int result = Test (typeof (X), typeof (X), typeof (Y), typeof (object));
 222                 if (result != 0)
 223                         return result;
 224
 225                 result = Test (typeof (Y), typeof (Y), typeof (object));
 226                 if (result != 0)
 227                         return 100 + result;
 228
 229                 result = Test (typeof (DateTime), typeof (DateTime));
 230                 if (result != 0)
 231                         return 200 + result;
 232
 233                 result = Test (typeof (float), typeof (float));
 234                 if (result != 0)
 235                         return 300 + result;
 236
 237                 result = Test (typeof (int), typeof (int), typeof (uint));
 238                 if (result != 0)
 239                         return 400 + result;
 240
 241                 result = Test (typeof (uint), typeof (int), typeof (uint));
 242                 if (result != 0)
 243                         return 500 + result;
 244
 245                 result = Test (typeof (long), typeof (long), typeof (ulong));
 246                 if (result != 0)
 247                         return 600 + result;
 248
 249                 result = Test (typeof (ulong), typeof (long), typeof (ulong));
 250                 if (result != 0)
 251                         return 700 + result;
 252
 253                 result = Test (typeof (short), typeof (short), typeof (ushort));
 254                 if (result != 0)
 255                         return 800 + result;
 256
 257                 result = Test (typeof (ushort), typeof (short), typeof (ushort));
 258                 if (result != 0)
 259                         return 900 + result;
 260
 261                 result = Test (typeof (Foo), typeof (Foo));
 262                 if (result != 0)
 263                         return 1000 + result;
 264
 265                 return 0;
 266         }
 267 }
 268
 269 class Z
 270 {
 271         static int Test ()
 272         {
 273                 int result;
 274                 result = CollectionTester.Test ();
 275                 if (result != 0)
 276                         return result;
 277                 result = InterfaceTester.Test ();
 278                 if (result != 0)
 279                         return 10000 + result;
 280                 return 0;
 281         }
 282
 283         static int Main ()
 284         {
 285                 int result = Test ();
 286                 if (result == 0)
 287                         Console.WriteLine ("OK");
 288                 else
 289                         Console.WriteLine ("ERROR: {0}", result);
 290                 return result;
 291         }
 292 }