mono/mini/generics.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Linq;
   4
   5 class Tests {
   6
   7         struct TestStruct {
   8                 public int i;
   9                 public int j;
  10
  11                 public TestStruct (int i, int j) {
  12                         this.i = i;
  13                         this.j = j;
  14                 }
  15         }
  16
  17         class Enumerator <T> : MyIEnumerator <T> {
  18                 T MyIEnumerator<T>.Current {
  19                         get {
  20                                 return default(T);
  21                         }
  22                 }
  23
  24                 bool MyIEnumerator<T>.MoveNext () {
  25                         return true;
  26                 }
  27         }
  28
  29         class Comparer <T> : IComparer <T> {
  30                 bool IComparer<T>.Compare (T x, T y) {
  31                         return true;
  32                 }
  33         }
  34
  35         static int Main (string[] args)
  36         {
  37                 return TestDriver.RunTests (typeof (Tests), args);
  38         }
  39
  40         public static int test_1_nullable_unbox ()
  41         {
  42                 return Unbox<int?> (1).Value;
  43         }
  44
  45         public static int test_1_nullable_unbox_null ()
  46         {
  47                 return Unbox<int?> (null).HasValue ? 0 : 1;
  48         }
  49
  50         public static int test_1_nullable_box ()
  51         {
  52                 return (int) Box<int?> (1);
  53         }
  54
  55         public static int test_1_nullable_box_null ()
  56         {
  57                 return Box<int?> (null) == null ? 1 : 0;
  58         }
  59
  60         public static int test_1_isinst_nullable ()
  61         {
  62                 object o = 1;
  63                 return (o is int?) ? 1 : 0;
  64         }
  65
  66         public static int test_1_nullable_unbox_vtype ()
  67         {
  68                 return Unbox<TestStruct?> (new TestStruct (1, 2)).Value.i;
  69         }
  70
  71         public static int test_1_nullable_unbox_null_vtype ()
  72         {
  73                 return Unbox<TestStruct?> (null).HasValue ? 0 : 1;
  74         }
  75
  76         public static int test_1_nullable_box_vtype ()
  77         {
  78                 return ((TestStruct)(Box<TestStruct?> (new TestStruct (1, 2)))).i;
  79         }
  80
  81         public static int test_1_nullable_box_null_vtype ()
  82         {
  83                 return Box<TestStruct?> (null) == null ? 1 : 0;
  84         }
  85
  86         public static int test_1_isinst_nullable_vtype ()
  87         {
  88                 object o = new TestStruct (1, 2);
  89                 return (o is TestStruct?) ? 1 : 0;
  90         }
  91
  92         public static int test_0_nullable_normal_unbox ()
  93         {
  94                 int? i = 5;
  95
  96                 object o = i;
  97                 // This uses unbox instead of unbox_any
  98                 int? j = (int?)o;
  99
 100                 if (j != 5)
 101                         return 1;
 102
 103                 return 0;
 104         }
 105
 106         public static void stelem_any<T> (T[] arr, T elem) {
 107                 arr [0] = elem;
 108         }
 109
 110         public static T ldelem_any<T> (T[] arr) {
 111                 return arr [0];
 112         }
 113
 114         public static int test_1_ldelem_stelem_any_int () {
 115                 int[] arr = new int [3];
 116                 stelem_any (arr, 1);
 117
 118                 return ldelem_any (arr);
 119         }
 120
 121         public static T return_ref<T> (ref T t) {
 122                 return t;
 123         }
 124
 125         public static T ldelema_any<T> (T[] arr) {
 126                 return return_ref<T> (ref arr [0]);
 127         }
 128
 129         public static int test_0_ldelema () {
 130                 string[] arr = new string [1];
 131
 132                 arr [0] = "Hello";
 133
 134                 if (ldelema_any <string> (arr) == "Hello")
 135                         return 0;
 136                 else
 137                         return 1;
 138         }
 139
 140         public static T[,] newarr_multi<T> () {
 141                 return new T [1, 1];
 142         }
 143
 144         public static int test_0_newarr_multi_dim () {
 145                 return newarr_multi<string> ().GetType () == typeof (string[,]) ? 0 : 1;
 146         }
 147
 148         interface ITest
 149         {
 150                 void Foo<T> ();
 151         }
 152
 153         public static int test_0_iface_call_null_bug_77442 () {
 154                 ITest test = null;
 155
 156                 try {
 157                         test.Foo<int> ();
 158                 }
 159                 catch (NullReferenceException) {
 160                         return 0;
 161                 }
 162
 163                 return 1;
 164         }
 165
 166         public static int test_18_ldobj_stobj_generics () {
 167                 GenericClass<int> t = new GenericClass <int> ();
 168                 int i = 5;
 169                 int j = 6;
 170                 return t.ldobj_stobj (ref i, ref j) + i + j;
 171         }
 172
 173         public static int test_5_ldelem_stelem_generics () {
 174                 GenericClass<TestStruct> t = new GenericClass<TestStruct> ();
 175
 176                 TestStruct s = new TestStruct (5, 5);
 177                 return t.ldelem_stelem (s).i;
 178         }
 179
 180         public static int test_0_constrained_vtype_box () {
 181                 GenericClass<TestStruct> t = new GenericClass<TestStruct> ();
 182
 183                 return t.toString (new TestStruct ()) == "Tests+TestStruct" ? 0 : 1;
 184         }
 185
 186         public static int test_0_constrained_vtype () {
 187                 GenericClass<int> t = new GenericClass<int> ();
 188
 189                 return t.toString (1234) == "1234" ? 0 : 1;
 190         }
 191
 192         public static int test_0_constrained_reftype () {
 193                 GenericClass<String> t = new GenericClass<String> ();
 194
 195                 return t.toString ("1234") == "1234" ? 0 : 1;
 196         }
 197
 198         public static int test_0_box_brtrue_optimizations () {
 199                 if (IsNull<int>(5))
 200                         return 1;
 201
 202                 if (!IsNull<object>(null))
 203                         return 1;
 204
 205                 return 0;
 206         }
 207
 208         [Category ("!FULLAOT")]
 209         public static int test_0_generic_get_value_optimization_int () {
 210                 int[] x = new int[] {100, 200};
 211
 212                 if (GenericClass<int>.Z (x, 0) != 100)
 213                         return 2;
 214
 215                 if (GenericClass<int>.Z (x, 1) != 200)
 216                         return 3;
 217
 218                 return 0;
 219         }
 220
 221         public static int test_0_generic_get_value_optimization_vtype () {
 222                 TestStruct[] arr = new TestStruct[] { new TestStruct (100, 200), new TestStruct (300, 400) };
 223                 IEnumerator<TestStruct> enumerator = GenericClass<TestStruct>.Y (arr);
 224                 TestStruct s;
 225                 int sum = 0;
 226                 while (enumerator.MoveNext ()) {
 227                         s = enumerator.Current;
 228                         sum += s.i + s.j;
 229                 }
 230
 231                 if (sum != 1000)
 232                         return 1;
 233
 234                 s = GenericClass<TestStruct>.Z (arr, 0);
 235                 if (s.i != 100 || s.j != 200)
 236                         return 2;
 237
 238                 s = GenericClass<TestStruct>.Z (arr, 1);
 239                 if (s.i != 300 || s.j != 400)
 240                         return 3;
 241
 242                 return 0;
 243         }
 244
 245         public static int test_0_nullable_ldflda () {
 246                 return GenericClass<string>.BIsAClazz == false ? 0 : 1;
 247         }
 248
 249         public struct GenericStruct<T> {
 250                 public T t;
 251
 252                 public GenericStruct (T t) {
 253                         this.t = t;
 254                 }
 255         }
 256
 257         public class GenericClass<T> {
 258                 public T t;
 259
 260                 public GenericClass (T t) {
 261                         this.t = t;
 262                 }
 263
 264                 public GenericClass () {
 265                 }
 266
 267                 public T ldobj_stobj (ref T t1, ref T t2) {
 268                         t1 = t2;
 269                         T t = t1;
 270
 271                         return t;
 272                 }
 273
 274                 public T ldelem_stelem (T t) {
 275                         T[] arr = new T [10];
 276                         arr [0] = t;
 277
 278                         return arr [0];
 279                 }
 280
 281                 public String toString (T t) {
 282                         return t.ToString ();
 283                 }
 284
 285                 public static IEnumerator<T> Y (IEnumerable <T> x)
 286                 {
 287                         return x.GetEnumerator ();
 288                 }
 289
 290                 public static T Z (IList<T> x, int index)
 291                 {
 292                         return x [index];
 293                 }
 294
 295         protected static T NullB = default(T);
 296         private static Nullable<bool>  _BIsA = null;
 297         public static bool BIsAClazz {
 298             get {
 299                 _BIsA = false;
 300                 return _BIsA.Value;
 301             }
 302         }
 303         }
 304
 305         public class MRO : MarshalByRefObject {
 306                 public GenericStruct<int> struct_field;
 307                 public GenericClass<int> class_field;
 308         }
 309
 310         public static int test_0_ldfld_stfld_mro () {
 311                 MRO m = new MRO ();
 312                 GenericStruct<int> s = new GenericStruct<int> (5);
 313                 // This generates stfld
 314                 m.struct_field = s;
 315
 316                 // This generates ldflda
 317                 if (m.struct_field.t != 5)
 318                         return 1;
 319
 320                 // This generates ldfld
 321                 GenericStruct<int> s2 = m.struct_field;
 322                 if (s2.t != 5)
 323                         return 2;
 324
 325                 if (m.struct_field.t != 5)
 326                         return 3;
 327
 328                 m.class_field = new GenericClass<int> (5);
 329                 if (m.class_field.t != 5)
 330                         return 4;
 331
 332                 return 0;
 333         }
 334
 335         // FIXME:
 336         [Category ("!FULLAOT")]
 337     public static int test_0_generic_virtual_call_on_vtype_unbox () {
 338                 object o = new Object ();
 339         IFoo h = new Handler(o);
 340
 341         if (h.Bar<object> () != o)
 342                         return 1;
 343                 else
 344                         return 0;
 345     }
 346
 347         public static int test_0_box_brtrue_opt () {
 348                 Foo<int> f = new Foo<int> (5);
 349
 350                 f [123] = 5;
 351
 352                 return 0;
 353         }
 354
 355         public static int test_0_box_brtrue_opt_regress_81102 () {
 356                 if (new Foo<int>(5).ToString () == "null")
 357                         return 0;
 358                 else
 359                         return 1;
 360         }
 361
 362         struct S {
 363                 public int i;
 364         }
 365
 366         public static int test_0_ldloca_initobj_opt () {
 367                 if (new Foo<S> (new S ()).get_default ().i != 0)
 368                         return 1;
 369                 if (new Foo<object> (null).get_default () != null)
 370                         return 2;
 371                 return 0;
 372         }
 373
 374         public static int test_0_variance_reflection () {
 375                 // covariance on IEnumerator
 376                 if (!typeof (MyIEnumerator<object>).IsAssignableFrom (typeof (MyIEnumerator<string>)))
 377                         return 1;
 378                 // covariance on IEnumerator and covariance on arrays
 379                 if (!typeof (MyIEnumerator<object>[]).IsAssignableFrom (typeof (MyIEnumerator<string>[])))
 380                         return 2;
 381                 // covariance and implemented interfaces
 382                 if (!typeof (MyIEnumerator<object>).IsAssignableFrom (typeof (Enumerator<string>)))
 383                         return 3;
 384
 385                 // contravariance on IComparer
 386                 if (!typeof (IComparer<string>).IsAssignableFrom (typeof (IComparer<object>)))
 387                         return 4;
 388                 // contravariance on IComparer, contravariance on arrays
 389                 if (!typeof (IComparer<string>[]).IsAssignableFrom (typeof (IComparer<object>[])))
 390                         return 5;
 391                 // contravariance and interface inheritance
 392                 if (!typeof (IComparer<string>[]).IsAssignableFrom (typeof (IKeyComparer<object>[])))
 393                         return 6;
 394                 return 0;
 395         }
 396
 397         public static int test_0_ldvirtftn_generic_method () {
 398                 new Tests ().ldvirtftn<string> ();
 399
 400                 return the_type == typeof (string) ? 0 : 1;
 401         }
 402
 403         public static int test_0_throw_dead_this () {
 404         new Foo<string> ("").throw_dead_this ();
 405                 return 0;
 406         }
 407
 408         // This cannot be made to work with full-aot, since there it is impossible to
 409         // statically determine that Foo<string>.Bar <int> is needed, the code only
 410         // references IFoo.Bar<int>
 411         [Category ("!FULLAOT")]
 412         public static int test_0_generic_virtual_on_interfaces () {
 413                 Foo<string>.count1 = 0;
 414                 Foo<string>.count2 = 0;
 415                 Foo<string>.count3 = 0;
 416
 417                 IFoo f = new Foo<string> ("");
 418                 for (int i = 0; i < 1000; ++i) {
 419                         f.Bar <int> ();
 420                         f.Bar <string> ();
 421                         f.NonGeneric ();
 422                 }
 423
 424                 if (Foo<string>.count1 != 1000)
 425                         return 1;
 426                 if (Foo<string>.count2 != 1000)
 427                         return 2;
 428                 if (Foo<string>.count3 != 1000)
 429                         return 3;
 430
 431                 VirtualInterfaceCallFromGenericMethod<long> (f);
 432
 433                 return 0;
 434         }
 435
 436         //repro for #505375
 437         [Category ("!FULLAOT")]
 438         public static int test_2_cprop_bug () {
 439                 int idx = 0;
 440                 int a = 1;
 441                 var cmp = System.Collections.Generic.Comparer<int>.Default ;
 442                 if (cmp.Compare (a, 0) > 0)
 443                         a = 0;
 444                 do { idx++; } while (cmp.Compare (idx - 1, a) == 0);
 445                 return idx;
 446         }
 447
 448         enum MyEnumUlong : ulong {
 449                 Value_2 = 2
 450         }
 451
 452         public static int test_0_regress_550964_constrained_enum_long () {
 453         MyEnumUlong a = MyEnumUlong.Value_2;
 454         MyEnumUlong b = MyEnumUlong.Value_2;
 455
 456         return Pan (a, b) ? 0 : 1;
 457         }
 458
 459     static bool Pan<T> (T a, T b)
 460     {
 461         return a.Equals (b);
 462     }
 463
 464         public class XElement {
 465                 public string Value {
 466                         get; set;
 467                 }
 468         }
 469
 470         public static int test_0_fullaot_linq () {
 471                 var allWords = new XElement [] { new XElement { Value = "one" } };
 472                 var filteredWords = allWords.Where(kw => kw.Value.StartsWith("T"));
 473                 return filteredWords.Count ();
 474         }
 475
 476         public static int test_0_fullaot_comparer_t () {
 477                 var l = new SortedList <TimeSpan, int> ();
 478                 return l.Count;
 479         }
 480
 481         static void enumerate<T> (IEnumerable<T> arr) {
 482                 foreach (var o in arr)
 483                         ;
 484                 int c = ((ICollection<T>)arr).Count;
 485         }
 486
 487         /* Test that treating arrays as generic collections works with full-aot */
 488         public static int test_0_fullaot_array_wrappers () {
 489                 Tests[] arr = new Tests [10];
 490                 enumerate<Tests> (arr);
 491                 return 0;
 492         }
 493
 494         static int cctor_count = 0;
 495
 496     public abstract class Beta<TChanged>
 497     {
 498         static Beta()
 499         {
 500                         cctor_count ++;
 501         }
 502     }
 503
 504     public class Gamma<T> : Beta<T>
 505     {
 506         static Gamma()
 507         {
 508         }
 509     }
 510
 511         // #519336
 512         public static int test_2_generic_class_init_gshared_ctor () {
 513                 new Gamma<object>();
 514                 new Gamma<string>();
 515
 516                 return cctor_count;
 517         }
 518
 519         public static void VirtualInterfaceCallFromGenericMethod <T> (IFoo f) {
 520                 f.Bar <T> ();
 521         }
 522
 523         public static Type the_type;
 524
 525         public void ldvirtftn<T> () {
 526                 Foo <T> binding = new Foo <T> (default (T));
 527
 528                 binding.GenericEvent += event_handler;
 529                 binding.fire ();
 530         }
 531
 532         public virtual void event_handler<T> (Foo<T> sender) {
 533                 the_type = typeof (T);
 534         }
 535
 536         public interface IFoo {
 537                 void NonGeneric ();
 538                 object Bar<T>();
 539         }
 540
 541         public class Foo<T1> : IFoo
 542         {
 543                 public Foo(T1 t1)
 544                 {
 545                         m_t1 = t1;
 546                 }
 547
 548                 public override string ToString()
 549                 {
 550                         return Bar(m_t1 == null ? "null" : "null");
 551                 }
 552
 553                 public String Bar (String s) {
 554                         return s;
 555                 }
 556
 557                 public int this [T1 key] {
 558                         set {
 559                                 if (key == null)
 560                                         throw new ArgumentNullException ("key");
 561                         }
 562                 }
 563
 564                 public void throw_dead_this () {
 565                         try {
 566                                 new SomeClass().ThrowAnException();
 567                         }
 568                         catch {
 569                         }
 570                 }
 571
 572                 public T1 get_default () {
 573                         return default (T1);
 574                 }
 575
 576                 readonly T1 m_t1;
 577
 578                 public delegate void GenericEventHandler (Foo<T1> sender);
 579
 580                 public event GenericEventHandler GenericEvent;
 581
 582                 public void fire () {
 583                         GenericEvent (this);
 584                 }
 585
 586                 public static int count1, count2, count3;
 587
 588                 public void NonGeneric () {
 589                         count3 ++;
 590                 }
 591
 592                 public object Bar <T> () {
 593                         if (typeof (T) == typeof (int))
 594                                 count1 ++;
 595                         else if (typeof (T) == typeof (string))
 596                                 count2 ++;
 597                         return null;
 598                 }
 599         }
 600
 601         public class SomeClass {
 602                 public void ThrowAnException() {
 603                         throw new Exception ("Something went wrong");
 604                 }
 605         }
 606
 607         struct Handler : IFoo {
 608                 object o;
 609
 610                 public Handler(object o) {
 611                         this.o = o;
 612                 }
 613
 614                 public void NonGeneric () {
 615                 }
 616
 617                 public object Bar<T>() {
 618                         return o;
 619                 }
 620         }
 621
 622         static bool IsNull<T> (T t)
 623         {
 624                 if (t == null)
 625                         return true;
 626                 else
 627                         return false;
 628         }
 629
 630         static object Box<T> (T t)
 631         {
 632                 return t;
 633         }
 634
 635         static T Unbox <T> (object o) {
 636                 return (T) o;
 637         }
 638 }