mcs/class/Mono.Debugger.Soft/Test/dtest-app.cs

   1 /*
   2  * dtest-app.cs:
   3  *
   4  *   Application program used by the debugger tests.
   5  */
   6 using System;
   7 using System.Runtime.CompilerServices;
   8 using System.Reflection;
   9 using System.Reflection.Emit;
  10 using System.Diagnostics;
  11 using System.Threading;
  12 using System.Threading.Tasks;
  13 using System.Collections.Generic;
  14 using System.Linq;
  15 using System.Net.Sockets;
  16 using MonoTests.Helpers;
  17
  18 public class TestsBase
  19 {
  20 #pragma warning disable 0414
  21 #pragma warning disable 0169
  22         public int base_field_i;
  23         public string base_field_s;
  24         static int base_static_i = 57;
  25         static string base_static_s = "C";
  26 #pragma warning restore 0414
  27 #pragma warning restore 0169
  28
  29         public virtual string virtual_method () {
  30                 return "V1";
  31         }
  32 }
  33
  34 public enum AnEnum {
  35         A = 0,
  36         B= 1
  37 }
  38
  39 public sealed class Tests3 {
  40         public static void M1 () {
  41         }
  42
  43         static void M2 () {
  44         }
  45
  46         public void M3 () {
  47         }
  48
  49         void M4 () {
  50         }
  51
  52 }
  53
  54 public static class Tests4 {
  55         static Tests4 () {
  56         }
  57 }
  58
  59 public class AAttribute : Attribute {
  60         public int afield;
  61 }
  62
  63 public class BAttribute : AAttribute {
  64         public int bfield;
  65 }
  66
  67 [DebuggerDisplay ("Tests", Name="FOO", Target=typeof (int))]
  68 [DebuggerTypeProxy (typeof (Tests))]
  69 [BAttribute (afield = 1, bfield = 2)]
  70 public class Tests2 {
  71         [DebuggerBrowsableAttribute (DebuggerBrowsableState.Collapsed)]
  72         public int field_j;
  73         public static int static_field_j;
  74
  75         [DebuggerBrowsableAttribute (DebuggerBrowsableState.Collapsed)]
  76         public int AProperty {
  77                 get {
  78                         return 0;
  79                 }
  80         }
  81
  82         public void invoke () {
  83         }
  84 }
  85
  86 public struct AStruct : ITest2 {
  87         public int i;
  88         public string s;
  89         public byte k;
  90         public IntPtr j;
  91         public int l;
  92 /*
  93         public AStruct () {
  94                 i = 0;
  95                 s = null;
  96                 k = 0;
  97                 j = IntPtr.Zero;
  98                 l = 0;
  99         }
 100 */
 101         public AStruct (int arg) {
 102                 i = arg;
 103                 s = null;
 104                 k = 0;
 105                 j = IntPtr.Zero;
 106                 l = 0;
 107         }
 108
 109         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 110         public int foo (int val) {
 111                 return val;
 112         }
 113
 114         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 115         public static int static_foo (int val) {
 116                 return val;
 117         }
 118
 119         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 120         public int invoke_return_int () {
 121                 return i;
 122         }
 123
 124         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 125         public static int invoke_static () {
 126                 return 5;
 127         }
 128
 129         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 130         public IntPtr invoke_return_intptr () {
 131                 return j;
 132         }
 133
 134         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 135         public void invoke_mutate () {
 136                 l = 5;
 137         }
 138
 139         public int invoke_iface () {
 140                 return i;
 141         }
 142
 143         public override string ToString () {
 144                 return i.ToString ();
 145         }
 146 }
 147
 148 public class GClass<T> {
 149         public T field;
 150         public static T static_field;
 151
 152         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 153         public GClass () {
 154         }
 155
 156         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 157         public void bp<T2> () {
 158         }
 159 }
 160
 161 public struct GStruct<T> {
 162         public T i;
 163
 164         public int j;
 165
 166         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 167         public int invoke_return_int () {
 168                 return j;
 169         }
 170 }
 171
 172 public struct NestedStruct {
 173         NestedInner nested1, nested2;
 174 }
 175
 176 public struct NestedInner {
 177 }
 178
 179 public interface IRecStruct {
 180         void foo (object o);
 181 }
 182
 183 struct RecStruct : IRecStruct {
 184         public object o;
 185
 186         public void foo (object o) {
 187                 this.o = o;
 188         }
 189 }
 190
 191 interface ITest
 192 {
 193         void Foo ();
 194         void Bar ();
 195 }
 196
 197 interface ITest<T>
 198 {
 199         void Foo ();
 200         void Bar ();
 201 }
 202
 203 class TestIfaces : ITest
 204 {
 205         void ITest.Foo () {
 206         }
 207
 208         void ITest.Bar () {
 209         }
 210
 211         TestIfaces<int> Baz () {
 212                 return null;
 213         }
 214 }
 215
 216 class TestIfaces<T> : ITest<T>
 217 {
 218         void ITest<T>.Foo () {
 219         }
 220
 221         void ITest<T>.Bar () {
 222         }
 223 }
 224
 225 public interface ITest2
 226 {
 227         int invoke_iface ();
 228 }
 229
 230 public class Tests : TestsBase, ITest2
 231 {
 232 #pragma warning disable 0414
 233         int field_i;
 234         string field_s;
 235         AnEnum field_enum;
 236         bool field_bool1, field_bool2;
 237         char field_char;
 238         byte field_byte;
 239         sbyte field_sbyte;
 240         short field_short;
 241         ushort field_ushort;
 242         long field_long;
 243         ulong field_ulong;
 244         float field_float;
 245         double field_double;
 246         Thread field_class;
 247         IntPtr field_intptr;
 248         int? field_nullable;
 249         static int static_i = 55;
 250         static string static_s = "A";
 251         public const int literal_i = 56;
 252         public const string literal_s = "B";
 253         public object child;
 254         public AStruct field_struct;
 255         public object field_boxed_struct;
 256         public GStruct<int> generic_field_struct;
 257         public KeyValuePair<int, object> boxed_struct_field;
 258         [ThreadStatic]
 259         public static int tls_i;
 260         public static bool is_attached = Debugger.IsAttached;
 261         public NestedStruct nested_struct;
 262
 263 #pragma warning restore 0414
 264
 265         public class NestedClass {
 266         }
 267
 268         public int IntProperty {
 269                 get {
 270                         return field_i;
 271                 }
 272                 set {
 273                         field_i = value;
 274                 }
 275         }
 276
 277         public int ReadOnlyProperty {
 278                 get {
 279                         return field_i;
 280                 }
 281         }
 282
 283         public int this [int index] {
 284                 get {
 285                         return field_i;
 286                 }
 287         }
 288
 289         public static void wait_one ()
 290         {
 291                 ManualResetEvent evt = new ManualResetEvent (false);
 292                 evt.WaitOne ();
 293         }
 294
 295         public static int Main (String[] args) {
 296                 tls_i = 42;
 297
 298                 if (args.Length > 0 && args [0] == "suspend-test")
 299                         /* This contains an infinite loop, so execute it conditionally */
 300                         suspend ();
 301                 if (args.Length >0 && args [0] == "unhandled-exception") {
 302                         unhandled_exception ();
 303                         return 0;
 304                 }
 305                 if (args.Length >0 && args [0] == "unhandled-exception-endinvoke") {
 306                         unhandled_exception_endinvoke ();
 307                         return 0;
 308                 }
 309                 if (args.Length >0 && args [0] == "unhandled-exception-user") {
 310                         unhandled_exception_user ();
 311                         return 0;
 312                 }
 313                 if (args.Length >0 && args [0] == "wait-one") {
 314                         wait_one ();
 315                         return 0;
 316                 }
 317                 if (args.Length >0 && args [0] == "threadpool-io") {
 318                         threadpool_io ();
 319                         return 0;
 320                 }
 321                 assembly_load ();
 322                 breakpoints ();
 323                 single_stepping ();
 324                 arguments ();
 325                 objects ();
 326                 objrefs ();
 327                 vtypes ();
 328                 locals ();
 329                 line_numbers ();
 330                 type_info ();
 331                 invoke ();
 332                 exceptions ();
 333                 exception_filter ();
 334                 threads ();
 335                 dynamic_methods ();
 336                 user ();
 337                 type_load ();
 338                 regress ();
 339                 gc_suspend ();
 340                 set_ip ();
 341                 step_filters ();
 342                 local_reflect ();
 343                 if (args.Length > 0 && args [0] == "domain-test")
 344                         /* This takes a lot of time, so execute it conditionally */
 345                         domains ();
 346                 if (args.Length > 0 && args [0] == "ref-emit-test")
 347                         ref_emit ();
 348                 if (args.Length > 0 && args [0] == "frames-in-native")
 349                         frames_in_native ();
 350                 if (args.Length > 0 && args [0] == "invoke-single-threaded")
 351                         new Tests ().invoke_single_threaded ();
 352                 if (args.Length > 0 && args [0] == "invoke-abort")
 353                         new Tests ().invoke_abort ();
 354                 new Tests ().evaluate_method ();
 355                 return 3;
 356         }
 357
 358         public static void local_reflect () {
 359                 //Breakpoint line below, and reflect someField via ObjectMirror;
 360                 LocalReflectClass.RunMe ();
 361         }
 362
 363         public static void breakpoints () {
 364                 /* Call these early so it is JITted by the time a breakpoint is placed on it */
 365                 bp3 ();
 366                 bp7<int> ();
 367                 bp7<string> ();
 368
 369                 bp1 ();
 370                 bp2 ();
 371                 bp3 ();
 372                 bp4 ();
 373                 bp4 ();
 374                 bp4 ();
 375                 bp5 ();
 376                 bp6<string> (new GClass <int> ());
 377                 bp7<int> ();
 378                 bp7<string> ();
 379         }
 380
 381         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 382         public static void bp1 () {
 383         }
 384
 385         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 386         public static void bp2 () {
 387         }
 388
 389         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 390         public static void bp3 () {
 391         }
 392
 393         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 394         public static void bp4 () {
 395         }
 396
 397         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 398         public static void bp5 () {
 399         }
 400
 401         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 402         public static void bp6<T> (GClass<int> gc) {
 403                 gc.bp<int> ();
 404         }
 405
 406         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 407         public static void bp7<T> () {
 408         }
 409
 410         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 411         public static void single_stepping () {
 412                 bool b = true;
 413                 ss1 ();
 414                 ss2 ();
 415                 ss3 ();
 416                 ss3_2 ();
 417                 ss4 ();
 418                 ss5 (new int [] { 1, 2, 3 }, new Func<int, bool> (is_even));
 419                 try {
 420                         ss6 (b);
 421                 } catch {
 422                 }
 423                 ss7 ();
 424                 ss_nested ();
 425                 ss_regress_654694 ();
 426                 ss_step_through ();
 427                 ss_non_user_code ();
 428                 ss_recursive (1);
 429                 ss_recursive2 (1);
 430                 ss_recursive2 (1);
 431                 ss_recursive_chaotic ();
 432                 ss_fp_clobber ();
 433                 ss_no_frames ();
 434         }
 435
 436         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 437         public static void ss1 () {
 438         }
 439
 440         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 441         public static void ss2 () {
 442         }
 443
 444         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 445         public static int ss3 () {
 446                 int sum = 0;
 447
 448                 for (int i = 0; i < 10; ++i)
 449                         sum += i;
 450
 451                 return sum;
 452         }
 453
 454         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 455         public static void ss3_2 () {
 456                 ss3_2_2 ();
 457         }
 458
 459         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 460         public static void ss3_2_2 () {
 461         }
 462
 463         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 464         public static int ss4 () {
 465                 ss1 (); ss1 ();
 466                 ss2 ();
 467                 return 0;
 468         }
 469
 470         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 471         public static void ss5 (int[] arr, Func<int, bool> selector) {
 472                 // Call into linq which calls back into this assembly
 473                 arr.Count (selector);
 474         }
 475
 476         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 477         public static void ss6 (bool b) {
 478                 if (b) {
 479                         ss6_2 ();
 480                         throw new Exception ();
 481                 }
 482         }
 483
 484         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 485         public static void ss6_2 () {
 486         }
 487
 488         [MethodImplAttribute(MethodImplOptions.NoInlining)]
 489         public static void ss7 ()
 490         {
 491                 ss7_2();//Used to test stepout inside ss7_2, which may not go to catch
 492                 ss7_2();//Used to test stepout inside ss7_2_1, which must go to catch
 493                 ss7_2();//Used to test stepover inside ss7_2, which must go to catch
 494                 ss7_2();//Used to test stepover inside ss7_2_1, which must go to catch
 495                 ss7_3();//Used to test stepin inside ss7_3, which must go to catch
 496                 ss7_2();//Used to test stepin inside ss7_2_1, which must go to catch
 497         }
 498
 499         [MethodImplAttribute(MethodImplOptions.NoInlining)]
 500         public static void ss7_2_1 ()
 501         {
 502                 throw new Exception ();
 503         }
 504
 505         [MethodImplAttribute(MethodImplOptions.NoInlining)]
 506         public static void ss7_2_2 ()
 507         {
 508                 ss7_2_1();
 509         }
 510
 511         [MethodImplAttribute(MethodImplOptions.NoInlining)]
 512         public static void ss7_2 ()
 513         {
 514                 try {
 515                         ss7_2_2();
 516                 }
 517                 catch
 518                 {
 519                 }
 520         }
 521
 522         [MethodImplAttribute(MethodImplOptions.NoInlining)]
 523         public static void ss7_3 ()
 524         {
 525                 try {
 526                         throw new Exception ();
 527                 }
 528                 catch
 529                 {
 530                 }
 531         }
 532
 533         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 534         public static void ss_nested () {
 535                 ss_nested_1 (ss_nested_2 ());
 536                 ss_nested_1 (ss_nested_2 ());
 537                 ss_nested_3 ();
 538         }
 539
 540         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 541         public static void ss_nested_1 (int i) {
 542         }
 543
 544         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 545         public static int ss_nested_2 () {
 546                 return 0;
 547         }
 548
 549         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 550         public static void ss_nested_3 () {
 551         }
 552
 553         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 554         public static void ss_step_through () {
 555                 step_through_1 ();
 556                 StepThroughClass.step_through_2 ();
 557                 step_through_3 ();
 558         }
 559
 560         [DebuggerStepThrough]
 561         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 562         public static void step_through_1 () {
 563         }
 564
 565         [DebuggerStepThrough]
 566         class StepThroughClass {
 567                 [MethodImplAttribute (MethodImplOptions.NoInlining)]
 568                 public static void step_through_2 () {
 569                 }
 570         }
 571
 572         [DebuggerStepThrough]
 573         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 574         public static void step_through_3 () {
 575         }
 576
 577         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 578         public static void ss_non_user_code () {
 579                 non_user_code_1 ();
 580                 StepNonUserCodeClass.non_user_code_2 ();
 581                 non_user_code_3 ();
 582         }
 583
 584         [DebuggerNonUserCode]
 585         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 586         public static void non_user_code_1 () {
 587         }
 588
 589         [DebuggerNonUserCode]
 590         class StepNonUserCodeClass {
 591                 [MethodImplAttribute (MethodImplOptions.NoInlining)]
 592                 public static void non_user_code_2 () {
 593                 }
 594         }
 595
 596         [DebuggerNonUserCode]
 597         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 598         public static void non_user_code_3 () {
 599         }
 600
 601         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 602         public static void ss_recursive (int n) {
 603                 if (n == 10)
 604                         return;
 605                 ss_recursive (n + 1);
 606         }
 607
 608         // Breakpoint will be placed here
 609         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 610         public static void ss_recursive2_trap ()
 611         {
 612         }
 613
 614         public static void ss_recursive2_at (string s)
 615         {
 616                 // Console.WriteLine (s);
 617         }
 618
 619         // This method is used both for a step over and step out test.
 620         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 621         public static void ss_recursive2 (int x)
 622         {
 623                 ss_recursive2_at ( "ss_recursive2 in " + x);
 624                 if (x < 5) {
 625                         int next = x + 1;
 626                         ss_recursive2_at ("ss_recursive2 descend " + x);
 627                         ss_recursive2_trap ();
 628                         ss_recursive2 (next);
 629                 }
 630                 ss_recursive2_at ("ss_recursive2 out " + x);
 631         }
 632
 633         // Breakpoint will be placed here
 634         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 635         public static void ss_recursive_chaotic_trap ()
 636         {
 637         }
 638
 639         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 640         public static void ss_recursive_chaotic_at (bool exiting, string at, int n)
 641         {
 642 //              string indent = "";
 643 //              for (int count = 5 - n; count > 0; count--)
 644 //                      indent += "\t";
 645 //              Console.WriteLine (indent + (exiting ? "<--" : "-->") + " " + at + " " + n);
 646         }
 647
 648         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 649         public static void ss_recursive_chaotic_fizz (int n)
 650         {
 651                 ss_recursive_chaotic_at (false, "fizz", n);
 652                 if (n > 0) {
 653                         int next = n - 1;
 654                         ss_recursive_chaotic_buzz (next);
 655                         ss_recursive_chaotic_fizzbuzz (next);
 656                 } else {
 657                         ss_recursive_chaotic_trap ();
 658                 }
 659                 ss_recursive_chaotic_at (true, "fizz", n);
 660         }
 661
 662         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 663         public static void ss_recursive_chaotic_buzz (int n)
 664         {
 665                 ss_recursive_chaotic_at (false, "buzz", n);
 666                 if (n > 0) {
 667                         int next = n - 1;
 668                         ss_recursive_chaotic_fizz (next);
 669                         ss_recursive_chaotic_fizzbuzz (next);
 670                 }
 671                 ss_recursive_chaotic_at (true, "buzz", n);
 672         }
 673
 674         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 675         public static void ss_recursive_chaotic_fizzbuzz (int n)
 676         {
 677                 ss_recursive_chaotic_at (false, "fizzbuzz", n);
 678                 if (n > 0) {
 679                         int next = n - 1;
 680                         ss_recursive_chaotic_fizz (next);
 681                         ss_recursive_chaotic_buzz (next);
 682                         ss_recursive_chaotic_fizzbuzz (next);
 683                 }
 684                 ss_recursive_chaotic_at (true, "fizzbuzz", n);
 685         }
 686
 687         // Call a complex tree of recursive calls that has tripped up "step out" in the past.
 688         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 689         public static void ss_recursive_chaotic ()
 690         {
 691                 ss_recursive_chaotic_fizz (5);
 692         }
 693
 694         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 695         public static void ss_fp_clobber () {
 696                 double v = ss_fp_clobber_1 (5.0);
 697                 ss_fp_clobber_2 (v);
 698         }
 699
 700         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 701         public static double ss_fp_clobber_1 (double d) {
 702                 return d + 2.0;
 703         }
 704
 705         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 706         public static void ss_fp_clobber_2 (double d) {
 707         }
 708
 709         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 710         public static void ss_no_frames () {
 711                 Action a = ss_no_frames_2;
 712                 var ar = a.BeginInvoke (null, null);
 713                 ar.AsyncWaitHandle.WaitOne ();
 714                 // Avoid waiting every time this runs
 715                 if (static_i == 56)
 716                         Thread.Sleep (200);
 717                 ss_no_frames_3 ();
 718         }
 719
 720         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 721         public static void ss_no_frames_2 () {
 722         }
 723
 724         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 725         public static void ss_no_frames_3 () {
 726         }
 727
 728         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 729         public static bool is_even (int i) {
 730                 return i % 2 == 0;
 731         }
 732
 733         /*
 734                 lock (static_s) {
 735                         Console.WriteLine ("HIT!");
 736                 }
 737                 return 0;
 738         }
 739         */
 740
 741         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 742         public static void arguments () {
 743                 arg1 (SByte.MaxValue - 5, Byte.MaxValue - 5, true, Int16.MaxValue - 5, UInt16.MaxValue - 5, 'F', Int32.MaxValue - 5, UInt32.MaxValue - 5, Int64.MaxValue - 5, UInt64.MaxValue - 5, 1.2345f, 6.78910, new IntPtr (Int32.MaxValue - 5), new UIntPtr (UInt32.MaxValue - 5));
 744                 int i = 42;
 745                 arg2 ("FOO", null, "BLA", ref i, new GClass <int> { field = 42 }, new object (), '\0'.ToString () + "A");
 746                 Tests t = new Tests () { field_i = 42, field_s = "S" };
 747                 t.arg3 ("BLA");
 748         }
 749
 750         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 751         public static int arg1 (sbyte sb, byte b, bool bl, short s, ushort us, char c, int i, uint ui, long l, ulong ul, float f, double d, IntPtr ip, UIntPtr uip) {
 752                 return (int)(sb + b + (bl ? 0 : 1) + s + us + (int)c + i + ui + l + (long)ul + f + d + (int)ip + (int)uip);
 753         }
 754
 755         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 756         public static string arg2 (string s, string s3, object o, ref int i, GClass <int> gc, object o2, string s4) {
 757                 return s + (s3 != null ? "" : "") + o + i + gc.field + o2;
 758         }
 759
 760         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 761         public object arg3 (string s) {
 762                 return s + s + s + s + this;
 763         }
 764
 765         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 766         public static void objects () {
 767                 Tests t = new Tests () { field_i = 42, field_bool1 = true, field_bool2 = false, field_char = 'A', field_byte = 129, field_sbyte = -33, field_short = Int16.MaxValue - 5, field_ushort = UInt16.MaxValue - 5, field_long = Int64.MaxValue - 5, field_ulong = UInt64.MaxValue - 5, field_float = 3.14f, field_double = 3.14f, field_s = "S", base_field_i = 43, base_field_s = "T", field_enum = AnEnum.B, field_class = null, field_intptr = new IntPtr (Int32.MaxValue - 5), field_nullable = null };
 768                 t.o1 (new Tests2 () { field_j = 43 }, new GClass <int> { field = 42 }, new GClass <string> { field = "FOO" });
 769                 o2 (new string [] { "BAR", "BAZ" }, new int[] { 42, 43 }, new int [,] { { 1, 2 }, { 3, 4 }}, (int[,])Array.CreateInstance (typeof (int), new int [] { 2, 2}, new int [] { 1, 3}), new int[] { 0 });
 770         }
 771
 772         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 773         public object o1 (Tests2 t, GClass <int> gc1, GClass <string> gc2) {
 774                 if (t == null || gc1 == null || gc2 == null)
 775                         return null;
 776                 else
 777                         return this;
 778         }
 779
 780         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 781         public static string o2 (string[] s2, int[] s3, int[,] s4, int[,] s5, IList<int> s6) {
 782                 return s2 [0] + s3 [0] + s4 [0, 0] + s6 [0];
 783         }
 784
 785         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 786         public static void objrefs () {
 787                 Tests t = new Tests () {};
 788                 set_child (t);
 789                 t.objrefs1 ();
 790                 t.child = null;
 791                 GC.Collect ();
 792                 objrefs2 ();
 793         }
 794
 795         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 796         public static void set_child (Tests t) {
 797                 t.child = new Tests ();
 798         }
 799
 800         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 801         public void objrefs1 () {
 802         }
 803
 804         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 805         public static void objrefs2 () {
 806         }
 807
 808         public static void vtypes () {
 809                 Tests t = new Tests () { field_struct = new AStruct () { i = 42, s = "S", k = 43 }, generic_field_struct = new GStruct<int> () { i = 42 }, field_boxed_struct = new AStruct () { i = 42 }, boxed_struct_field = new KeyValuePair<int, object> (1, (long)42 ) };
 810                 AStruct s = new AStruct { i = 44, s = "T", k = 45 };
 811                 AStruct[] arr = new AStruct[] {
 812                         new AStruct () { i = 1, s = "S1" },
 813                         new AStruct () { i = 2, s = "S2" } };
 814                 TypedReference typedref = __makeref (s);
 815                 t.vtypes1 (s, arr, typedref);
 816                 vtypes2 (s);
 817                 vtypes3 (s);
 818                 vtypes4 ();
 819         }
 820
 821         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 822         public object vtypes1 (AStruct s, AStruct[] arr, TypedReference typedref) {
 823                 if (arr != null)
 824                         return this;
 825                 else
 826                         return null;
 827         }
 828
 829         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 830         public static void vtypes2 (AStruct s) {
 831                 s.foo (5);
 832         }
 833
 834         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 835         public static void vtypes3 (AStruct s) {
 836                 AStruct.static_foo (5);
 837         }
 838
 839         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 840         public static void vtypes4_2 (IRecStruct o) {
 841         }
 842
 843         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 844         public static void vtypes4 () {
 845                 IRecStruct s = new RecStruct ();
 846                 s.foo (s);
 847                 vtypes4_2 (s);
 848         }
 849
 850         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 851         public static void locals () {
 852                 string s = null;
 853                 var astruct = new AStruct () { i = 42 };
 854                 locals1 (null);
 855                 locals2<string> (null, 5, "ABC", ref s, ref astruct);
 856                 locals3 ();
 857                 locals6 ();
 858                 locals7<int> (22);
 859         }
 860
 861         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 862         static void locals11 (double a, ref double b) {
 863         }
 864
 865         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 866         public static void locals1 (string[] args) {
 867                 long foo = 42;
 868
 869                 double ri = 1;
 870                 locals11 (b: ref ri, a: ri);
 871
 872                 for (int j = 0; j < 10; ++j) {
 873                         foo ++;
 874                 }
 875         }
 876
 877         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 878         [StateMachine (typeof (int))]
 879         public static void locals2<T> (string[] args, int arg, T t, ref string rs, ref AStruct astruct) {
 880                 long i = 42;
 881                 string s = "AB";
 882
 883                 for (int j = 0; j < 10; ++j) {
 884                         if (s != null)
 885                                 i ++;
 886                         if (t != null)
 887                                 i ++;
 888                         astruct = new AStruct ();
 889                 }
 890                 rs = "A";
 891                 List<int> alist = new List<int> () { 12 };
 892         }
 893
 894
 895         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 896         public static void locals3 () {
 897                 string s = "B";
 898                 s.ToString ();
 899
 900                 {
 901                         long i = 42;
 902                         i ++;
 903                         locals4 ();
 904                 }
 905                 {
 906                         string i = "A";
 907                         i.ToString ();
 908                         locals5 ();
 909                 }
 910                 {
 911                         long j = 42;
 912                         j ++;
 913                 }
 914         }
 915
 916         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 917         public static void locals4 () {
 918         }
 919
 920         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 921         public static void locals5 () {
 922         }
 923
 924         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 925         public static void locals6 () {
 926                 int i = 0;
 927                 int j = 0;
 928                 for (i = 0; i < 10; ++i)
 929                         j ++;
 930                 sbyte sb = 0;
 931                 for (i = 0; i < 10; ++i)
 932                         sb ++;
 933                 locals6_1 ();
 934                 locals6_2 (j);
 935                 locals6_3 ();
 936                 locals6_4 (j);
 937                 locals6_5 ();
 938                 locals6_6 (sb);
 939         }
 940
 941         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 942         public static void locals6_1 () {
 943         }
 944
 945         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 946         public static void locals6_2 (int arg) {
 947         }
 948
 949         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 950         public static void locals6_3 () {
 951                 // Clobber all registers
 952                 int sum = 0, i, j, k, l, m;
 953                 for (i = 0; i < 100; ++i)
 954                         sum ++;
 955                 for (j = 0; j < 100; ++j)
 956                         sum ++;
 957                 for (k = 0; k < 100; ++k)
 958                         sum ++;
 959                 for (l = 0; l < 100; ++l)
 960                         sum ++;
 961                 for (m = 0; m < 100; ++m)
 962                         sum ++;
 963         }
 964
 965         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 966         public static void locals6_4 (int arg) {
 967         }
 968
 969         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 970         public static void locals6_5 () {
 971         }
 972
 973         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 974         public static void locals6_6 (int arg) {
 975         }
 976
 977         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 978         public static void locals7<T> (T arg) {
 979                 T t = arg;
 980                 T t2 = t;
 981         }
 982
 983         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 984         public static void line_numbers () {
 985                 LineNumbers.ln1 ();
 986         }
 987
 988         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 989         public static void suspend () {
 990                 long i = 5;
 991
 992                 while (true) {
 993                         i ++;
 994                 }
 995         }
 996
 997         struct TypedRefTest {
 998                 public int MaxValue;
 999         }
1000
1001         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1002         public static void type_info () {
1003                 Tests t = new Tests () { field_i = 42, field_s = "S", base_field_i = 43, base_field_s = "T", field_enum = AnEnum.B };
1004                 t.ti1 (new Tests2 () { field_j = 43 }, new GClass <int> { field = 42 }, new GClass <string> { field = "FOO" });
1005                 int val = 0;
1006                 unsafe {
1007                         AStruct s = new AStruct () { i = 42, s = "S", k = 43 };
1008                         TypedRefTest reftest = new TypedRefTest () { MaxValue = 12 };
1009                         TypedReference typedref = __makeref (reftest);
1010                         ti2 (new string [] { "BAR", "BAZ" }, new int[] { 42, 43 }, new int [,] { { 1, 2 }, { 3, 4 }}, ref val, (int*)IntPtr.Zero, 5, s, new Tests (), new Tests2 (), new GClass <int> (), AnEnum.B, typedref);
1011                 }
1012         }
1013
1014         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1015         public object ti1 (Tests2 t, GClass <int> gc1, GClass <string> gc2) {
1016                 if (t == null || gc1 == null || gc2 == null)
1017                         return null;
1018                 else
1019                         return this;
1020         }
1021
1022         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1023         public static unsafe string ti2 (string[] s2, int[] s3, int[,] s4, ref int ri, int* ptr, int i, AStruct s, Tests t, Tests2 t2, GClass<int> g, AnEnum ae, TypedReference typedref) {
1024                 return s2 [0] + s3 [0] + s4 [0, 0];
1025         }
1026
1027         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1028         public static void assembly_load () {
1029                 assembly_load_2 ();
1030         }
1031
1032         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1033         public static void assembly_load_2 () {
1034                 // This will load System.dll while holding the loader lock
1035                 new Foo ();
1036         }
1037
1038         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1039         public static void invoke () {
1040                 new Tests ().invoke1 (new Tests2 (), new AStruct () { i = 42, j = (IntPtr)43 }, new GStruct<int> { j = 42 });
1041                 new Tests ().invoke_ex ();
1042         }
1043
1044         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1045         public void invoke1 (Tests2 t, AStruct s, GStruct<int> g) {
1046                 invoke2 ();
1047         }
1048
1049         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1050         public void invoke2 () {
1051         }
1052
1053         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1054         public void invoke_ex () {
1055                 invoke_ex_inner ();
1056         }
1057
1058         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1059         public void invoke_ex_inner () {
1060                 try {
1061                         throw new Exception ();
1062                 } catch {
1063                 }
1064         }
1065
1066         int counter;
1067
1068         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1069         public void invoke_single_threaded () {
1070                 // Spawn a thread incrementing a counter
1071                 bool finished = false;
1072
1073                 new Thread (delegate () {
1074                                 while (!finished)
1075                                         counter ++;
1076                 }).Start ();
1077
1078                 Thread.Sleep (100);
1079
1080                 invoke_single_threaded_2 ();
1081
1082                 finished = true;
1083         }
1084
1085         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1086         public void invoke_single_threaded_2 () {
1087         }
1088
1089         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1090         public void invoke_abort () {
1091         }
1092
1093         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1094         public void invoke_abort_2 () {
1095                 Thread.Sleep (1000000);
1096         }
1097
1098         public void invoke_return_void () {
1099         }
1100
1101         public string invoke_return_ref () {
1102                 return "ABC";
1103         }
1104
1105         public object invoke_return_null () {
1106                 return null;
1107         }
1108
1109         public int invoke_return_primitive () {
1110                 return 42;
1111         }
1112
1113         public int? invoke_return_nullable () {
1114                 return 42;
1115         }
1116
1117         public int? invoke_return_nullable_null () {
1118                 return null;
1119         }
1120
1121         public void invoke_type_load () {
1122                 new Class3 ();
1123         }
1124
1125         class Class3 {
1126         }
1127
1128         public long invoke_pass_primitive (byte ub, sbyte sb, short ss, ushort us, int i, uint ui, long l, ulong ul, char c, bool b, float f, double d) {
1129                 return ub + sb + ss + us + i + ui + l + (long)ul + (int)c + (b ? 1 : 0) + (int)f + (int)d;
1130         }
1131
1132         public int invoke_pass_primitive2 (bool b) {
1133                 return b ? 1 : 0;
1134         }
1135
1136         public string invoke_pass_ref (string s) {
1137                 return s;
1138         }
1139
1140         public static string invoke_static_pass_ref (string s) {
1141                 return s;
1142         }
1143
1144         public static void invoke_static_return_void () {
1145         }
1146
1147         public static void invoke_throws () {
1148                 throw new Exception ();
1149         }
1150
1151         public int invoke_iface () {
1152                 return 42;
1153         }
1154
1155         public void invoke_out (out int foo, out int[] arr) {
1156                 foo = 5;
1157                 arr = new int [10];
1158         }
1159
1160         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1161         public static void exceptions () {
1162                 try {
1163                         throw new OverflowException ();
1164                 } catch (Exception) {
1165                 }
1166                 try {
1167                         throw new OverflowException ();
1168                 } catch (Exception) {
1169                 }
1170                 try {
1171                         throw new ArgumentException ();
1172                 } catch (Exception) {
1173                 }
1174                 try {
1175                         throw new OverflowException ();
1176                 } catch (Exception) {
1177                 }
1178                 // no subclasses
1179                 try {
1180                         throw new OverflowException ();
1181                 } catch (Exception) {
1182                 }
1183                 try {
1184                         throw new Exception ();
1185                 } catch (Exception) {
1186                 }
1187
1188                 object o = null;
1189                 try {
1190                         o.GetType ();
1191                 } catch (Exception) {
1192                 }
1193
1194                 try {
1195                         exceptions2 ();
1196                 } catch (Exception) {
1197                 }
1198         }
1199
1200         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1201         public static void unhandled_exception () {
1202                 ThreadPool.QueueUserWorkItem (delegate {
1203                                 throw new InvalidOperationException ();
1204                         });
1205                 Thread.Sleep (10000);
1206         }
1207
1208         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1209         public static void unhandled_exception_endinvoke_2 () {
1210         }
1211
1212         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1213         public static void unhandled_exception_endinvoke () {
1214                         Action action = new Action (() =>
1215                         {
1216                                 throw new Exception ("thrown");
1217                         });
1218                         action.BeginInvoke ((ar) => {
1219                                 try {
1220                                         action.EndInvoke (ar);
1221                                 } catch (Exception ex) {
1222                                         //Console.WriteLine (ex);
1223                                 }
1224                         }, null);
1225                 Thread.Sleep (1000);
1226                 unhandled_exception_endinvoke_2 ();
1227         }
1228
1229         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1230         public static void unhandled_exception_user () {
1231                 System.Threading.Tasks.Task.Factory.StartNew (() => {
1232                                 Throw ();
1233                         });
1234                 Thread.Sleep (10000);
1235         }
1236
1237         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1238         public static void Throw () {
1239                 throw new Exception ();
1240         }
1241
1242         internal static Delegate create_filter_delegate (Delegate dlg, MethodInfo filter_method)
1243         {
1244                 if (dlg == null)
1245                         throw new ArgumentNullException ();
1246                 if (dlg.Target != null)
1247                         throw new ArgumentException ();
1248                 if (dlg.Method == null)
1249                         throw new ArgumentException ();
1250
1251                 var ret_type = dlg.Method.ReturnType;
1252                 var param_types = dlg.Method.GetParameters ().Select (x => x.ParameterType).ToArray ();
1253
1254                 var dynamic = new DynamicMethod (Guid.NewGuid ().ToString (), ret_type, param_types, typeof (object), true);
1255                 var ig = dynamic.GetILGenerator ();
1256
1257                 LocalBuilder retval = null;
1258                 if (ret_type != typeof (void))
1259                         retval = ig.DeclareLocal (ret_type);
1260
1261                 var label = ig.BeginExceptionBlock ();
1262
1263                 for (int i = 0; i < param_types.Length; i++)
1264                         ig.Emit (OpCodes.Ldarg, i);
1265                 ig.Emit (OpCodes.Call, dlg.Method);
1266
1267                 if (retval != null)
1268                         ig.Emit (OpCodes.Stloc, retval);
1269
1270                 ig.Emit (OpCodes.Leave, label);
1271
1272                 ig.BeginExceptFilterBlock ();
1273
1274                 ig.Emit (OpCodes.Call, filter_method);
1275
1276                 ig.BeginCatchBlock (null);
1277
1278                 ig.Emit (OpCodes.Pop);
1279
1280                 ig.EndExceptionBlock ();
1281
1282                 if (retval != null)
1283                         ig.Emit (OpCodes.Ldloc, retval);
1284
1285                 ig.Emit (OpCodes.Ret);
1286
1287                 return dynamic.CreateDelegate (dlg.GetType ());
1288         }
1289
1290         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1291         static void exception_filter_method () {
1292                 throw new InvalidOperationException ();
1293         }
1294
1295         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1296         static int exception_filter_filter (Exception exc) {
1297                 return 1;
1298         }
1299
1300         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1301         public static void exception_filter () {
1302                 var method = typeof (Tests).GetMethod (
1303                         "exception_filter_method", BindingFlags.NonPublic | BindingFlags.Static);
1304                 var filter_method = typeof (Tests).GetMethod (
1305                         "exception_filter_filter", BindingFlags.NonPublic | BindingFlags.Static);
1306
1307                 var dlg = Delegate.CreateDelegate (typeof (Action), method);
1308
1309                 var wrapper = (Action) create_filter_delegate (dlg, filter_method);
1310
1311                 wrapper ();
1312         }
1313
1314         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1315         public static bool return_true () {
1316                 return true;
1317         }
1318
1319         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1320         public static void exceptions2 () {
1321                 if (return_true ())
1322                         throw new Exception ();
1323                 Console.WriteLine ();
1324         }
1325
1326         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1327         public static void threads () {
1328                 Thread t = new Thread (delegate () {});
1329
1330                 t.Start ();
1331                 t.Join ();
1332         }
1333
1334         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1335         public static void domains () {
1336                 AppDomain domain = AppDomain.CreateDomain ("domain");
1337
1338                 CrossDomain o = (CrossDomain)domain.CreateInstanceAndUnwrap (
1339                                    typeof (CrossDomain).Assembly.FullName, "CrossDomain");
1340
1341                 domains_print_across (o);
1342
1343                 domains_2 (o, new CrossDomain ());
1344
1345                 o.invoke_2 ();
1346
1347                 o.invoke ();
1348
1349                 o.invoke_2 ();
1350
1351                 o.assembly_load ();
1352
1353                 AppDomain.Unload (domain);
1354
1355                 domains_3 ();
1356
1357                 typeof (Tests).GetMethod ("called_from_invoke").Invoke (null, null);
1358         }
1359
1360         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1361         public static void called_from_invoke () {
1362         }
1363
1364         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1365         public static void domains_2 (object o, object o2) {
1366         }
1367
1368         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1369         public static void domains_print_across (object o) {
1370         }
1371
1372         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1373         public static void domains_3 () {
1374         }
1375
1376         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1377         public static void invoke_in_domain () {
1378         }
1379
1380         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1381         public static void invoke_in_domain_2 () {
1382         }
1383
1384         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1385         public static void assembly_load_in_domain () {
1386                 Assembly.Load ("System.Transactions");
1387         }
1388
1389         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1390         public static void dynamic_methods () {
1391                 var m = new DynamicMethod ("dyn_method", typeof (void), new Type []  { typeof (int) }, typeof (object).Module);
1392                 var ig = m.GetILGenerator ();
1393
1394                 ig.Emit (OpCodes.Ldstr, "FOO");
1395                 ig.Emit (OpCodes.Call, typeof (Tests).GetMethod ("dyn_call"));
1396                 ig.Emit (OpCodes.Ret);
1397
1398                 var del = (Action<int>)m.CreateDelegate (typeof (Action<int>));
1399
1400                 del (0);
1401         }
1402
1403         public static void dyn_call (string s) {
1404         }
1405
1406         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1407         public static void ref_emit () {
1408                 AssemblyName assemblyName = new AssemblyName ();
1409                 assemblyName.Name = "foo";
1410
1411                 AssemblyBuilder assembly =
1412                         Thread.GetDomain ().DefineDynamicAssembly (
1413                                                                                                            assemblyName, AssemblyBuilderAccess.RunAndSave);
1414
1415                 ModuleBuilder module = assembly.DefineDynamicModule ("foo.dll");
1416
1417                 TypeBuilder tb = module.DefineType ("foo", TypeAttributes.Public, typeof (object));
1418                 MethodBuilder mb = tb.DefineMethod ("ref_emit_method", MethodAttributes.Public|MethodAttributes.Static, CallingConventions.Standard, typeof (void), new Type [] { });
1419                 ILGenerator ig = mb.GetILGenerator ();
1420                 ig.Emit (OpCodes.Ldstr, "FOO");
1421                 ig.Emit (OpCodes.Call, typeof (Tests).GetMethod ("ref_emit_call"));
1422                 ig.Emit (OpCodes.Ret);
1423
1424                 Type t = tb.CreateType ();
1425
1426                 t.GetMethod ("ref_emit_method").Invoke (null, null);
1427         }
1428
1429         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1430         public static void ref_emit_call (string s) {
1431         }
1432
1433         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1434         public static void frames_in_native () {
1435                 Thread.Sleep (500);
1436                 var evt = new ManualResetEvent (false);
1437
1438                 object mon = new object ();
1439                 ThreadPool.QueueUserWorkItem (delegate {
1440                                 frames_in_native_2 ();
1441                                 evt.Set ();
1442                         });
1443                 evt.WaitOne ();
1444         }
1445
1446         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1447         static void frames_in_native_2 () {
1448                 frames_in_native_3 ();
1449         }
1450
1451         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1452         static void frames_in_native_3 () {
1453         }
1454
1455         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1456         public static void string_call (string s) {
1457         }
1458
1459         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1460         public static void ss_regress_654694 () {
1461                 if (true) {
1462                         string h = "hi";
1463                         string_call (h);
1464                 }
1465         }
1466
1467         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1468         public static void user () {
1469                 Debugger.Break ();
1470
1471                 Debugger.Log (5, Debugger.IsLogging () ? "A" : "", "B");
1472         }
1473
1474         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1475         public static void type_load () {
1476                 type_load_2 ();
1477         }
1478
1479         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1480         static void type_load_2 () {
1481                 var c1 = new Dictionary<int, int> ();
1482                 c1.ToString ();
1483                 var c = new TypeLoadClass ();
1484                 c.ToString ();
1485                 var c2 = new TypeLoadClass2 ();
1486                 c2.ToString ();
1487         }
1488
1489         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1490         public static void regress () {
1491                 regress_2755 (DateTime.Now);
1492         }
1493
1494         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1495         public static unsafe void regress_2755 (DateTime d) {
1496                 int* buffer = stackalloc int [128];
1497
1498                 regress_2755_2 ();
1499
1500                 int sum = 0;
1501                 for (int i = 0; i < 128; ++i)
1502                         sum += buffer [i];
1503
1504                 regress_2755_3 (sum);
1505         }
1506
1507         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1508         public static void regress_2755_2 () {
1509         }
1510
1511         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1512         public static void regress_2755_3 (int sum) {
1513         }
1514
1515         static object gc_suspend_field;
1516
1517         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1518         static unsafe void set_gc_suspend_field () {
1519                 set_gc_suspend_field_2 ();
1520                 // Clear stack
1521                 int* buffer = stackalloc int [4096];
1522         }
1523
1524         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1525         static void set_gc_suspend_field_2 () {
1526                 gc_suspend_field = new object ();
1527         }
1528
1529         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1530         static void gc_suspend_1 () {
1531         }
1532
1533         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1534         public static void gc_suspend_invoke () {
1535                 gc_suspend_field = null;
1536                 GC.Collect ();
1537                 GC.WaitForPendingFinalizers ();
1538         }
1539
1540         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1541         public static void gc_suspend () {
1542                 set_gc_suspend_field ();
1543                 gc_suspend_1 ();
1544         }
1545
1546         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1547         public static void generic_method<T> () where T : class {
1548         }
1549
1550         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1551         public void evaluate_method_2 () {
1552         }
1553
1554         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1555         public void evaluate_method () {
1556                 field_i = 42;
1557                 evaluate_method_2 ();
1558         }
1559
1560         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1561         static void set_ip_1 () {
1562         }
1563
1564         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1565         static void set_ip_2 () {
1566         }
1567
1568         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1569         public static void set_ip () {
1570                 int i = 0, j;
1571
1572                 i ++;
1573                 i ++;
1574                 set_ip_1 ();
1575                 i ++;
1576                 j = 5;
1577                 set_ip_2 ();
1578         }
1579
1580         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1581         public static void step_filters () {
1582                 ClassWithCctor.cctor_filter ();
1583         }
1584
1585         class ClassWithCctor {
1586                 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1587                 static ClassWithCctor () {
1588                         int i = 1;
1589                         int j = 2;
1590                 }
1591
1592                 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1593                 public static void cctor_filter () {
1594                 }
1595         }
1596
1597         public override string virtual_method () {
1598                 return "V2";
1599         }
1600
1601         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1602         public static void threadpool_bp () { }
1603
1604         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1605         public static void threadpool_io () {
1606                 // Start a threadpool task that blocks on I/O.
1607                 // Regression test for #42625
1608                 const int nbytes = 16;
1609                 var bsOut = new byte[nbytes];
1610                 for (int i = 0; i < nbytes; i++) {
1611                         bsOut[i] = (byte)i;
1612                 }
1613                 var endPoint = NetworkHelpers.LocalEphemeralEndPoint ();
1614                 var l = new TcpListener (endPoint);
1615                 l.Start ();
1616                 Task<byte[]> t = Task.Run (async () => {
1617                         var c = new TcpClient ();
1618                         await c.ConnectAsync (endPoint.Address, endPoint.Port);
1619                         var streamIn = c.GetStream ();
1620                         var bs = new byte[nbytes];
1621                         int nread = 0;
1622                         int nremain = nbytes;
1623                         while (nread < nbytes) {
1624                                 int r = await streamIn.ReadAsync (bs, nread, nremain);
1625                                 nread += r;
1626                                 nremain -= r;
1627                         }
1628                         streamIn.Close ();
1629                         return bs;
1630                         });
1631                 var s = l.AcceptTcpClient ();
1632                 l.Stop ();
1633                 // write bytes in two groups so that the task blocks on the ReadAsync
1634                 var streamOut = s.GetStream ();
1635                 var nbytesFirst = nbytes / 2;
1636                 var nbytesRest = nbytes - nbytesFirst;
1637                 streamOut.Write (bsOut, 0, nbytesFirst);
1638                 threadpool_bp ();
1639                 streamOut.Write (bsOut, nbytesFirst, nbytesRest);
1640                 streamOut.Close ();
1641                 var bsIn = t.Result;
1642         }
1643 }
1644
1645 public class SentinelClass : MarshalByRefObject {
1646 }
1647
1648 public class CrossDomain : MarshalByRefObject
1649 {
1650         SentinelClass printMe = new SentinelClass ();
1651
1652         public void invoke () {
1653                 Tests.invoke_in_domain ();
1654         }
1655
1656         public void invoke_2 () {
1657                 Tests.invoke_in_domain_2 ();
1658         }
1659
1660         public int invoke_3 () {
1661                 return 42;
1662         }
1663
1664         public void assembly_load () {
1665                 Tests.assembly_load_in_domain ();
1666         }
1667 }
1668
1669 public class Foo
1670 {
1671         public ProcessStartInfo info;
1672 }
1673
1674 class LocalReflectClass
1675 {
1676         public static void RunMe ()
1677         {
1678                 var reflectMe = new someClass ();
1679                 var temp = reflectMe; // Breakpoint location
1680                 reflectMe.someMethod ();
1681         }
1682
1683         class someClass : ContextBoundObject
1684         {
1685                 public object someField;
1686
1687                 public void someMethod ()
1688                 {
1689                 }
1690         }
1691 }
1692
1693 // Class used for line number info testing, don't change its layout
1694 public class LineNumbers
1695 {
1696         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1697         public static void ln1 () {
1698                 // Column 3
1699                 ln2 ();
1700                 ln3 ();
1701         }
1702
1703         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1704         public static void ln2 () {
1705         }
1706
1707         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1708         public static void ln3 () {
1709 #pragma warning disable 0219
1710                 int i = 5;
1711 #pragma warning restore 0219
1712                 #line 55 "FOO"
1713         }
1714 }
1715
1716
1717