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         struct S<T> {}
 409
 410         public static int test_0_inline_infinite_polymorphic_recursion () {
 411            f<int>(0);
 412
 413                    return 0;
 414         }
 415
 416         private static void f<T>(int i) {
 417                 if(i==42) f<S<T>>(i);
 418         }
 419
 420         // This cannot be made to work with full-aot, since there it is impossible to
 421         // statically determine that Foo<string>.Bar <int> is needed, the code only
 422         // references IFoo.Bar<int>
 423         [Category ("!FULLAOT")]
 424         public static int test_0_generic_virtual_on_interfaces () {
 425                 Foo<string>.count1 = 0;
 426                 Foo<string>.count2 = 0;
 427                 Foo<string>.count3 = 0;
 428
 429                 IFoo f = new Foo<string> ("");
 430                 for (int i = 0; i < 1000; ++i) {
 431                         f.Bar <int> ();
 432                         f.Bar <string> ();
 433                         f.NonGeneric ();
 434                 }
 435
 436                 if (Foo<string>.count1 != 1000)
 437                         return 1;
 438                 if (Foo<string>.count2 != 1000)
 439                         return 2;
 440                 if (Foo<string>.count3 != 1000)
 441                         return 3;
 442
 443                 VirtualInterfaceCallFromGenericMethod<long> (f);
 444
 445                 return 0;
 446         }
 447
 448         //repro for #505375
 449         [Category ("!FULLAOT")]
 450         public static int test_2_cprop_bug () {
 451                 int idx = 0;
 452                 int a = 1;
 453                 var cmp = System.Collections.Generic.Comparer<int>.Default ;
 454                 if (cmp.Compare (a, 0) > 0)
 455                         a = 0;
 456                 do { idx++; } while (cmp.Compare (idx - 1, a) == 0);
 457                 return idx;
 458         }
 459
 460         enum MyEnumUlong : ulong {
 461                 Value_2 = 2
 462         }
 463
 464         public static int test_0_regress_550964_constrained_enum_long () {
 465         MyEnumUlong a = MyEnumUlong.Value_2;
 466         MyEnumUlong b = MyEnumUlong.Value_2;
 467
 468         return Pan (a, b) ? 0 : 1;
 469         }
 470
 471     static bool Pan<T> (T a, T b)
 472     {
 473         return a.Equals (b);
 474     }
 475
 476         public class XElement {
 477                 public string Value {
 478                         get; set;
 479                 }
 480         }
 481
 482         public static int test_0_fullaot_linq () {
 483                 var allWords = new XElement [] { new XElement { Value = "one" } };
 484                 var filteredWords = allWords.Where(kw => kw.Value.StartsWith("T"));
 485                 return filteredWords.Count ();
 486         }
 487
 488         public static int test_0_fullaot_comparer_t () {
 489                 var l = new SortedList <TimeSpan, int> ();
 490                 return l.Count;
 491         }
 492
 493         static void enumerate<T> (IEnumerable<T> arr) {
 494                 foreach (var o in arr)
 495                         ;
 496                 int c = ((ICollection<T>)arr).Count;
 497         }
 498
 499         /* Test that treating arrays as generic collections works with full-aot */
 500         public static int test_0_fullaot_array_wrappers () {
 501                 Tests[] arr = new Tests [10];
 502                 enumerate<Tests> (arr);
 503                 return 0;
 504         }
 505
 506         static int cctor_count = 0;
 507
 508     public abstract class Beta<TChanged>
 509     {
 510         static Beta()
 511         {
 512                         cctor_count ++;
 513         }
 514     }
 515
 516     public class Gamma<T> : Beta<T>
 517     {
 518         static Gamma()
 519         {
 520         }
 521     }
 522
 523         // #519336
 524         public static int test_2_generic_class_init_gshared_ctor () {
 525                 new Gamma<object>();
 526                 new Gamma<string>();
 527
 528                 return cctor_count;
 529         }
 530
 531         public static Type get_type<T> () {
 532                 return typeof (T);
 533         }
 534
 535         public static int test_0_gshared_delegate_rgctx () {
 536                 Func<Type> t = new Func<Type> (get_type<string>);
 537
 538                 if (t () == typeof (string))
 539                         return 0;
 540                 else
 541                         return 1;
 542         }
 543
 544         // Creating a delegate from a generic method from gshared code
 545         public static int test_0_gshared_delegate_from_gshared () {
 546                 if (gshared_delegate_from_gshared <object> () != 0)
 547                         return 1;
 548                 if (gshared_delegate_from_gshared <string> () != 0)
 549                         return 2;
 550                 return 0;
 551         }
 552
 553         public static int gshared_delegate_from_gshared <T> () {
 554                 Func<Type> t = new Func<Type> (get_type<T>);
 555
 556                 return t () == typeof (T) ? 0 : 1;
 557         }
 558
 559         public static int test_0_marshalbyref_call_from_gshared_virt_elim () {
 560                 /* Calling a virtual method from gshared code which is changed to a nonvirt call */
 561                 Class1<object> o = new Class1<object> ();
 562                 o.Do (new Class2<object> ());
 563                 return 0;
 564         }
 565
 566     public class Class1<T> {
 567                 public virtual void Do (Class2<T> t) {
 568                         t.Foo ();
 569                 }
 570         }
 571
 572         public interface IFace1<T> {
 573                 void Foo ();
 574         }
 575
 576         public class Class2<T> : MarshalByRefObject, IFace1<T> {
 577                 public void Foo () {
 578                 }
 579         }
 580
 581
 582
 583         public static void VirtualInterfaceCallFromGenericMethod <T> (IFoo f) {
 584                 f.Bar <T> ();
 585         }
 586
 587         public static Type the_type;
 588
 589         public void ldvirtftn<T> () {
 590                 Foo <T> binding = new Foo <T> (default (T));
 591
 592                 binding.GenericEvent += event_handler;
 593                 binding.fire ();
 594         }
 595
 596         public virtual void event_handler<T> (Foo<T> sender) {
 597                 the_type = typeof (T);
 598         }
 599
 600         public interface IFoo {
 601                 void NonGeneric ();
 602                 object Bar<T>();
 603         }
 604
 605         public class Foo<T1> : IFoo
 606         {
 607                 public Foo(T1 t1)
 608                 {
 609                         m_t1 = t1;
 610                 }
 611
 612                 public override string ToString()
 613                 {
 614                         return Bar(m_t1 == null ? "null" : "null");
 615                 }
 616
 617                 public String Bar (String s) {
 618                         return s;
 619                 }
 620
 621                 public int this [T1 key] {
 622                         set {
 623                                 if (key == null)
 624                                         throw new ArgumentNullException ("key");
 625                         }
 626                 }
 627
 628                 public void throw_dead_this () {
 629                         try {
 630                                 new SomeClass().ThrowAnException();
 631                         }
 632                         catch {
 633                         }
 634                 }
 635
 636                 public T1 get_default () {
 637                         return default (T1);
 638                 }
 639
 640                 readonly T1 m_t1;
 641
 642                 public delegate void GenericEventHandler (Foo<T1> sender);
 643
 644                 public event GenericEventHandler GenericEvent;
 645
 646                 public void fire () {
 647                         GenericEvent (this);
 648                 }
 649
 650                 public static int count1, count2, count3;
 651
 652                 public void NonGeneric () {
 653                         count3 ++;
 654                 }
 655
 656                 public object Bar <T> () {
 657                         if (typeof (T) == typeof (int))
 658                                 count1 ++;
 659                         else if (typeof (T) == typeof (string))
 660                                 count2 ++;
 661                         return null;
 662                 }
 663         }
 664
 665         public class SomeClass {
 666                 public void ThrowAnException() {
 667                         throw new Exception ("Something went wrong");
 668                 }
 669         }
 670
 671         struct Handler : IFoo {
 672                 object o;
 673
 674                 public Handler(object o) {
 675                         this.o = o;
 676                 }
 677
 678                 public void NonGeneric () {
 679                 }
 680
 681                 public object Bar<T>() {
 682                         return o;
 683                 }
 684         }
 685
 686         static bool IsNull<T> (T t)
 687         {
 688                 if (t == null)
 689                         return true;
 690                 else
 691                         return false;
 692         }
 693
 694         static object Box<T> (T t)
 695         {
 696                 return t;
 697         }
 698
 699         static T Unbox <T> (object o) {
 700                 return (T) o;
 701         }
 702 }