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

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Threading;
   4 using System.Net;
   5 using System.Reflection;
   6 using System.Text;
   7 using Mono.Cecil.Cil;
   8 using Mono.Debugger.Soft;
   9 using Diag = System.Diagnostics;
  10 using System.Linq;
  11 using System.IO;
  12 using System.Security.Cryptography;
  13
  14 using NUnit.Framework;
  15
  16 #pragma warning disable 0219
  17
  18 namespace MonoTests
  19 {
  20
  21 [TestFixture]
  22 public class DebuggerTests
  23 {
  24         VirtualMachine vm;
  25         MethodMirror entry_point;
  26         StepEventRequest step_req;
  27         bool forceExit;
  28
  29         void AssertThrows<ExType> (Action del) where ExType : Exception {
  30                 bool thrown = false;
  31
  32                 try {
  33                         del ();
  34                 } catch (ExType) {
  35                         thrown = true;
  36                 }
  37                 Assert.IsTrue (thrown);
  38         }
  39
  40         // No other way to pass arguments to the tests ?
  41         public static bool listening = Environment.GetEnvironmentVariable ("DBG_SUSPEND") != null;
  42         public static string runtime = Environment.GetEnvironmentVariable ("DBG_RUNTIME");
  43         public static string agent_args = Environment.GetEnvironmentVariable ("DBG_AGENT_ARGS");
  44
  45         Event GetNextEvent () {
  46                 var es = vm.GetNextEventSet ();
  47                 Assert.AreEqual (1, es.Events.Length);
  48                 return es [0];
  49         }
  50
  51         void Start (params string[] args) {
  52                 Start (false, args);
  53         }
  54
  55         void Start (bool forceExit, params string[] args) {
  56                 this.forceExit = forceExit;
  57
  58                 if (!listening) {
  59                         var pi = new Diag.ProcessStartInfo ();
  60
  61                         if (runtime != null)
  62                                 pi.FileName = runtime;
  63                         else
  64                                 pi.FileName = "mono";
  65                         pi.Arguments = String.Join (" ", args);
  66                         vm = VirtualMachineManager.Launch (pi, new LaunchOptions { AgentArgs = agent_args });
  67                 } else {
  68                         var ep = new IPEndPoint (IPAddress.Any, 10000);
  69                         Console.WriteLine ("Listening on " + ep + "...");
  70                         vm = VirtualMachineManager.Listen (ep);
  71                 }
  72
  73                 var load_req = vm.CreateAssemblyLoadRequest ();
  74                 load_req.Enable ();
  75
  76                 Event vmstart = GetNextEvent ();
  77                 Assert.AreEqual (EventType.VMStart, vmstart.EventType);
  78
  79                 vm.Resume ();
  80
  81                 entry_point = null;
  82                 step_req = null;
  83
  84                 Event e;
  85
  86                 /* Find out the entry point */
  87                 while (true) {
  88                         e = GetNextEvent ();
  89
  90                         if (e is AssemblyLoadEvent) {
  91                                 AssemblyLoadEvent ae = (AssemblyLoadEvent)e;
  92                                 entry_point = ae.Assembly.EntryPoint;
  93                                 if (entry_point != null)
  94                                         break;
  95                         }
  96
  97                         vm.Resume ();
  98                 }
  99
 100                 load_req.Disable ();
 101         }
 102
 103         BreakpointEvent run_until (string name) {
 104                 // String
 105                 MethodMirror m = entry_point.DeclaringType.GetMethod (name);
 106                 Assert.IsNotNull (m);
 107                 //Console.WriteLine ("X: " + name + " " + m.ILOffsets.Count + " " + m.Locations.Count);
 108                 var req = vm.SetBreakpoint (m, m.ILOffsets [0]);
 109
 110                 Event e = null;
 111
 112                 while (true) {
 113                         vm.Resume ();
 114                         e = GetNextEvent ();
 115                         if (e is BreakpointEvent)
 116                                 break;
 117                 }
 118
 119                 req.Disable ();
 120
 121                 Assert.IsInstanceOfType (typeof (BreakpointEvent), e);
 122                 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
 123
 124                 return (e as BreakpointEvent);
 125         }
 126
 127         Event single_step (ThreadMirror t) {
 128                 var req = vm.CreateStepRequest (t);
 129                 req.Enable ();
 130
 131                 vm.Resume ();
 132                 Event e = GetNextEvent ();
 133                 Assert.IsTrue (e is StepEvent);
 134
 135                 req.Disable ();
 136
 137                 return e;
 138         }
 139
 140         Event step_until (ThreadMirror t, string method_name) {
 141                 Event e;
 142                 while (true) {
 143                         e = single_step (t);
 144                         if ((e as StepEvent).Method.Name == method_name)
 145                                 break;
 146                 }
 147                 return e;
 148         }
 149
 150         void check_arg_val (StackFrame frame, int pos, Type type, object eval) {
 151                 object val = frame.GetArgument (pos);
 152                 Assert.IsTrue (val is PrimitiveValue);
 153                 object v = (val as PrimitiveValue).Value;
 154                 Assert.AreEqual (type, v.GetType ());
 155                 if (eval is float)
 156                         Assert.IsTrue (Math.Abs ((float)eval - (float)v) < 0.0001);
 157                 else if (eval is double)
 158                         Assert.IsTrue (Math.Abs ((double)eval - (double)v) < 0.0001);
 159                 else
 160                         Assert.AreEqual (eval, v);
 161         }
 162
 163         void AssertValue (object expected, object val) {
 164                 if (expected is string) {
 165                         Assert.IsTrue (val is StringMirror);
 166                         Assert.AreEqual (expected, (val as StringMirror).Value);
 167                 } else if (val is StructMirror && (val as StructMirror).Type.Name == "IntPtr") {
 168                         AssertValue (expected, (val as StructMirror).Fields [0]);
 169                 } else {
 170                         Assert.IsTrue (val is PrimitiveValue);
 171                         Assert.AreEqual (expected, (val as PrimitiveValue).Value);
 172                 }
 173         }
 174
 175         [SetUp]
 176         public void SetUp () {
 177                 ThreadMirror.NativeTransitions = false;
 178                 Start (new string [] { "dtest-app.exe" });
 179         }
 180
 181         [TearDown]
 182         public void TearDown () {
 183                 if (vm == null)
 184                         return;
 185
 186                 if (step_req != null)
 187                         step_req.Disable ();
 188
 189                 vm.Resume ();
 190                 if (forceExit)
 191                         vm.Exit (0);
 192
 193                 while (true) {
 194                         Event e = GetNextEvent ();
 195
 196                         if (e is VMDeathEvent)
 197                                 break;
 198
 199                         vm.Resume ();
 200                 }
 201                 vm = null;
 202         }
 203
 204         [Test]
 205         public void SimpleBreakpoint () {
 206                 Event e;
 207
 208                 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp1");
 209                 Assert.IsNotNull (m);
 210
 211                 vm.SetBreakpoint (m, 0);
 212
 213                 vm.Resume ();
 214
 215                 e = GetNextEvent ();
 216                 Assert.AreEqual (EventType.Breakpoint, e.EventType);
 217                 Assert.IsTrue (e is BreakpointEvent);
 218                 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
 219
 220                 // Argument checking
 221                 AssertThrows<ArgumentException> (delegate {
 222                                 // Invalid IL offset
 223                                 vm.SetBreakpoint (m, 2);
 224                         });
 225         }
 226
 227         [Test]
 228         public void BreakpointsSameLocation () {
 229                 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp2");
 230                 Assert.IsNotNull (m);
 231
 232                 vm.SetBreakpoint (m, 0);
 233                 vm.SetBreakpoint (m, 0);
 234
 235                 vm.Resume ();
 236
 237                 var es = vm.GetNextEventSet ();
 238                 Assert.AreEqual (2, es.Events.Length);
 239                 Assert.IsTrue (es [0] is BreakpointEvent);
 240                 Assert.AreEqual (m, (es [0] as BreakpointEvent).Method);
 241
 242                 Assert.IsTrue (es [1] is BreakpointEvent);
 243                 Assert.AreEqual (m.Name, (es [1] as BreakpointEvent).Method.Name);
 244         }
 245
 246         [Test]
 247         public void BreakpointAlreadyJITted () {
 248                 Event e = run_until ("bp1");
 249
 250                 /* Place a breakpoint on bp3 */
 251                 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp3");
 252                 Assert.IsNotNull (m);
 253                 vm.SetBreakpoint (m, 0);
 254
 255                 /* Same with generic instances */
 256                 MethodMirror m2 = entry_point.DeclaringType.GetMethod ("bp7");
 257                 Assert.IsNotNull (m2);
 258                 vm.SetBreakpoint (m2, 0);
 259
 260                 vm.Resume ();
 261
 262                 e = GetNextEvent ();
 263                 Assert.AreEqual (EventType.Breakpoint, e.EventType);
 264                 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
 265
 266                 vm.Resume ();
 267
 268                 /* Non-shared instance */
 269                 e = GetNextEvent ();
 270                 Assert.AreEqual (EventType.Breakpoint, e.EventType);
 271                 Assert.AreEqual (m2.Name, (e as BreakpointEvent).Method.Name);
 272
 273                 vm.Resume ();
 274
 275                 /* Shared instance */
 276                 e = GetNextEvent ();
 277                 Assert.AreEqual (EventType.Breakpoint, e.EventType);
 278                 Assert.AreEqual (m2.Name, (e as BreakpointEvent).Method.Name);
 279         }
 280
 281         [Test]
 282         public void ClearBreakpoint () {
 283                 Event e;
 284
 285                 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp4");
 286                 Assert.IsNotNull (m);
 287                 EventRequest req1 = vm.SetBreakpoint (m, 0);
 288                 EventRequest req2 = vm.SetBreakpoint (m, 0);
 289
 290                 MethodMirror m2 = entry_point.DeclaringType.GetMethod ("bp5");
 291                 Assert.IsNotNull (m2);
 292                 vm.SetBreakpoint (m2, 0);
 293
 294                 /* Run until bp4 */
 295                 vm.Resume ();
 296
 297                 var es = vm.GetNextEventSet ();
 298                 Assert.AreEqual (2, es.Events.Length);
 299                 Assert.AreEqual (EventType.Breakpoint, es [0].EventType);
 300                 Assert.AreEqual (m.Name, (es [0] as BreakpointEvent).Method.Name);
 301                 Assert.AreEqual (EventType.Breakpoint, es [1].EventType);
 302                 Assert.AreEqual (m.Name, (es [1] as BreakpointEvent).Method.Name);
 303
 304                 /* Clear one of them */
 305                 req1.Disable ();
 306
 307                 vm.Resume ();
 308
 309                 e = GetNextEvent ();
 310                 Assert.AreEqual (EventType.Breakpoint, e.EventType);
 311                 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
 312
 313                 /* Clear the other */
 314                 req2.Disable ();
 315
 316                 vm.Resume ();
 317
 318                 e = GetNextEvent ();
 319                 Assert.AreEqual (EventType.Breakpoint, e.EventType);
 320                 Assert.AreEqual (m2.Name, (e as BreakpointEvent).Method.Name);
 321         }
 322
 323         [Test]
 324         public void ClearAllBreakpoints () {
 325                 Event e;
 326
 327                 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp4");
 328                 Assert.IsNotNull (m);
 329                 vm.SetBreakpoint (m, 0);
 330
 331                 MethodMirror m2 = entry_point.DeclaringType.GetMethod ("bp5");
 332                 Assert.IsNotNull (m2);
 333                 vm.SetBreakpoint (m2, 0);
 334
 335                 vm.ClearAllBreakpoints ();
 336
 337                 vm.Resume ();
 338
 339                 e = GetNextEvent ();
 340                 Assert.IsTrue (!(e is BreakpointEvent));
 341                 if (e is VMDeathEvent)
 342                         vm = null;
 343         }
 344
 345         [Test]
 346         public void BreakpointOnGShared () {
 347                 Event e;
 348
 349                 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp6");
 350                 Assert.IsNotNull (m);
 351
 352                 vm.SetBreakpoint (m, 0);
 353
 354                 vm.Resume ();
 355
 356                 e = GetNextEvent ();
 357                 Assert.AreEqual (EventType.Breakpoint, e.EventType);
 358                 Assert.IsTrue (e is BreakpointEvent);
 359                 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
 360
 361                 // Breakpoint on an open generic method of a closed generic class (#3422)
 362                 var frame = e.Thread.GetFrames ()[0];
 363                 var ginst = frame.GetValue (frame.Method.GetLocal ("gc"));
 364                 var m2 = (ginst as ObjectMirror).Type.GetMethod ("bp");
 365                 vm.SetBreakpoint (m2, 0);
 366
 367                 vm.Resume ();
 368
 369                 e = GetNextEvent ();
 370                 Assert.AreEqual (EventType.Breakpoint, e.EventType);
 371                 Assert.IsTrue (e is BreakpointEvent);
 372                 Assert.AreEqual (m2.Name, (e as BreakpointEvent).Method.Name);
 373         }
 374
 375         void assert_location (Event e, string method) {
 376                 Assert.IsTrue (e is StepEvent);
 377                 Assert.AreEqual (method, (e as StepEvent).Method.Name);
 378         }
 379
 380         StepEventRequest create_step (Event e) {
 381                 var req = vm.CreateStepRequest (e.Thread);
 382                 step_req = req;
 383                 return req;
 384         }
 385
 386         [Test]
 387         public void SingleStepping () {
 388                 Event e = run_until ("single_stepping");
 389
 390                 var req = create_step (e);
 391                 req.Enable ();
 392
 393                 // Step over 'bool b = true'
 394                 e = step_once ();
 395                 assert_location (e, "single_stepping");
 396
 397                 // Skip nop
 398                 step_once ();
 399
 400                 // Step into ss1
 401                 e = step_once ();
 402                 assert_location (e, "ss1");
 403
 404                 // Skip }
 405                 e = step_once ();
 406
 407                 // Step out of ss1
 408                 e = step_once ();
 409                 assert_location (e, "single_stepping");
 410
 411                 // Step over ss2
 412                 e = step_over ();
 413                 assert_location (e, "single_stepping");
 414
 415                 // Step into ss3
 416                 e = step_into ();
 417                 assert_location (e, "ss3");
 418
 419                 // Step back into single_stepping
 420                 e = step_out ();
 421                 assert_location (e, "single_stepping");
 422
 423                 // Step into ss3_2 ()
 424                 e = step_into ();
 425                 assert_location (e, "ss3_2");
 426
 427                 // Step over ss3_2_2 ()
 428                 e = step_over ();
 429                 assert_location (e, "ss3_2");
 430
 431                 // Recreate the request
 432                 req.Disable ();
 433                 req.Enable ();
 434
 435                 // Skip }
 436                 e = step_once ();
 437
 438                 // Step back into single_stepping () with the new request
 439                 e = step_once ();
 440                 assert_location (e, "single_stepping");
 441
 442                 // Step into ss4 ()
 443                 e = step_into ();
 444                 assert_location (e, "ss4");
 445
 446                 // Skip nop
 447                 e = step_once ();
 448
 449                 // Change to StepSize.Line
 450                 req.Disable ();
 451                 req.Depth = StepDepth.Over;
 452                 req.Size = StepSize.Line;
 453                 req.Enable ();
 454
 455                 // Step over ss1 (); ss1 ();
 456                 e = step_once ();
 457
 458                 // Step into ss2 ()
 459                 req.Disable ();
 460                 req.Depth = StepDepth.Into;
 461                 req.Enable ();
 462
 463                 e = step_once ();
 464                 assert_location (e, "ss2");
 465
 466                 req.Disable ();
 467
 468                 // Run until ss5
 469                 e = run_until ("ss5");
 470
 471                 // Add an assembly filter
 472                 req.AssemblyFilter = new AssemblyMirror [] { (e as BreakpointEvent).Method.DeclaringType.Assembly };
 473                 req.Enable ();
 474
 475                 // Skip nop
 476                 e = step_once ();
 477
 478                 // Step into is_even, skipping the linq stuff
 479                 e = step_once ();
 480                 assert_location (e, "is_even");
 481
 482                 // FIXME: Check that single stepping works with lock (obj)
 483                 req.Disable ();
 484
 485                 // Run until ss6
 486                 e = run_until ("ss6");
 487
 488                 req = create_step (e);
 489                 req.Depth = StepDepth.Over;
 490                 req.Enable ();
 491
 492                 // Check that single stepping works in out-of-line bblocks
 493                 e = step_once ();
 494                 e = step_once ();
 495                 assert_location (e, "ss6");
 496                 req.Disable ();
 497
 498                 // Check that a step over stops at an EH clause
 499                 e = run_until ("ss7_2");
 500                 req = create_step (e);
 501                 req.Depth = StepDepth.Out;
 502                 req.Enable ();
 503                 e = step_once ();
 504                 assert_location (e, "ss7");
 505                 req.Disable ();
 506                 req = create_step (e);
 507                 req.Depth = StepDepth.Over;
 508                 req.Enable ();
 509                 e = step_once ();
 510                 assert_location (e, "ss7");
 511                 req.Disable ();
 512
 513                 // Check that stepping stops between nested calls
 514                 e = run_until ("ss_nested_2");
 515                 e = step_out ();
 516                 assert_location (e, "ss_nested");
 517                 e = step_into ();
 518                 assert_location (e, "ss_nested_1");
 519                 e = step_out ();
 520                 assert_location (e, "ss_nested");
 521                 // Check that step over steps over nested calls
 522                 e = step_over ();
 523                 assert_location (e, "ss_nested");
 524                 e = step_into ();
 525                 assert_location (e, "ss_nested_3");
 526                 req.Disable ();
 527
 528                 // Check DebuggerStepThrough support
 529                 e = run_until ("ss_step_through");
 530                 req = create_step (e);
 531                 req.Filter = StepFilter.DebuggerStepThrough;
 532                 e = step_into ();
 533                 // Step through step_through_1 ()
 534                 e = step_into ();
 535                 assert_location (e, "ss_step_through");
 536                 // Step through StepThroughClass.step_through_2 ()
 537                 e = step_into ();
 538                 assert_location (e, "ss_step_through");
 539                 req.Disable ();
 540                 req.Filter = StepFilter.None;
 541                 e = step_into ();
 542                 assert_location (e, "step_through_3");
 543                 req.Disable ();
 544
 545                 // Check DebuggerNonUserCode support
 546                 e = run_until ("ss_non_user_code");
 547                 req = create_step (e);
 548                 req.Filter = StepFilter.DebuggerNonUserCode;
 549                 e = step_into ();
 550                 // Step through non_user_code_1 ()
 551                 e = step_into ();
 552                 assert_location (e, "ss_non_user_code");
 553                 // Step through StepThroughClass.non_user_code_2 ()
 554                 e = step_into ();
 555                 assert_location (e, "ss_non_user_code");
 556                 req.Disable ();
 557                 req.Filter = StepFilter.None;
 558                 e = step_into ();
 559                 assert_location (e, "non_user_code_3");
 560                 req.Disable ();
 561
 562                 // Check that step-over doesn't stop at inner frames with recursive functions
 563                 e = run_until ("ss_recursive");
 564                 req = create_step (e);
 565                 e = step_over ();
 566                 e = step_over ();
 567                 e = step_over ();
 568                 var f = e.Thread.GetFrames () [0];
 569                 assert_location (e, "ss_recursive");
 570                 AssertValue (1, f.GetValue (f.Method.GetLocal ("n")));
 571                 req.Disable ();
 572
 573                 // Check that single stepping doesn't clobber fp values
 574                 e = run_until ("ss_fp_clobber");
 575                 req = create_step (e);
 576                 while (true) {
 577                         f = e.Thread.GetFrames ()[0];
 578                         e = step_into ();
 579                         if ((e as StepEvent).Method.Name == "ss_fp_clobber_2")
 580                                 break;
 581                         e = step_into ();
 582                 }
 583                 f = e.Thread.GetFrames ()[0];
 584                 AssertValue (7.0, f.GetValue (f.Method.GetParameters ()[0]));
 585                 req.Disable ();
 586         }
 587
 588         [Test]
 589         public void MethodEntryExit () {
 590                 run_until ("single_stepping");
 591
 592                 var req1 = vm.CreateMethodEntryRequest ();
 593                 var req2 = vm.CreateMethodExitRequest ();
 594
 595                 req1.Enable ();
 596                 req2.Enable ();
 597
 598                 vm.Resume ();
 599                 Event e = GetNextEvent ();
 600                 Assert.IsTrue (e is MethodEntryEvent);
 601                 Assert.AreEqual ("ss1", (e as MethodEntryEvent).Method.Name);
 602
 603                 vm.Resume ();
 604                 e = GetNextEvent ();
 605                 Assert.IsTrue (e is MethodExitEvent);
 606                 Assert.AreEqual ("ss1", (e as MethodExitEvent).Method.Name);
 607
 608                 req1.Disable ();
 609                 req2.Disable ();
 610         }
 611
 612         [Test]
 613         public void CountFilter () {
 614                 run_until ("single_stepping");
 615
 616                 MethodMirror m2 = entry_point.DeclaringType.GetMethod ("ss3");
 617                 Assert.IsNotNull (m2);
 618                 vm.SetBreakpoint (m2, 0);
 619
 620                 var req1 = vm.CreateMethodEntryRequest ();
 621                 req1.Count = 2;
 622                 req1.Enable ();
 623
 624                 // Enter ss2, ss1 is skipped
 625                 vm.Resume ();
 626                 Event e = GetNextEvent ();
 627                 Assert.IsTrue (e is MethodEntryEvent);
 628                 Assert.AreEqual ("ss2", (e as MethodEntryEvent).Method.Name);
 629
 630                 // Breakpoint on ss3, the entry event is no longer reported
 631                 vm.Resume ();
 632                 e = GetNextEvent ();
 633                 Assert.IsTrue (e is BreakpointEvent);
 634
 635                 req1.Disable ();
 636         }
 637
 638         [Test]
 639         public void Arguments () {
 640                 object val;
 641
 642                 var e = run_until ("arg1");
 643
 644                 StackFrame frame = e.Thread.GetFrames () [0];
 645
 646                 check_arg_val (frame, 0, typeof (sbyte), SByte.MaxValue - 5);
 647                 check_arg_val (frame, 1, typeof (byte), Byte.MaxValue - 5);
 648                 check_arg_val (frame, 2, typeof (bool), true);
 649                 check_arg_val (frame, 3, typeof (short), Int16.MaxValue - 5);
 650                 check_arg_val (frame, 4, typeof (ushort), UInt16.MaxValue - 5);
 651                 check_arg_val (frame, 5, typeof (char), 'F');
 652                 check_arg_val (frame, 6, typeof (int), Int32.MaxValue - 5);
 653                 check_arg_val (frame, 7, typeof (uint), UInt32.MaxValue - 5);
 654                 check_arg_val (frame, 8, typeof (long), Int64.MaxValue - 5);
 655                 check_arg_val (frame, 9, typeof (ulong), UInt64.MaxValue - 5);
 656                 check_arg_val (frame, 10, typeof (float), 1.2345f);
 657                 check_arg_val (frame, 11, typeof (double), 6.78910);
 658
 659                 e = run_until ("arg2");
 660
 661                 frame = e.Thread.GetFrames () [0];
 662
 663                 // String
 664                 val = frame.GetArgument (0);
 665                 AssertValue ("FOO", val);
 666                 Assert.AreEqual ("String", (val as ObjectMirror).Type.Name);
 667
 668                 // null
 669                 val = frame.GetArgument (1);
 670                 AssertValue (null, val);
 671
 672                 // object
 673                 val = frame.GetArgument (2);
 674                 AssertValue ("BLA", val);
 675
 676                 // byref
 677                 val = frame.GetArgument (3);
 678                 AssertValue (42, val);
 679
 680                 // generic instance
 681                 val = frame.GetArgument (4);
 682                 Assert.IsTrue (val is ObjectMirror);
 683                 Assert.AreEqual ("GClass`1", (val as ObjectMirror).Type.Name);
 684
 685                 // System.Object
 686                 val = frame.GetArgument (5);
 687                 Assert.IsTrue (val is ObjectMirror);
 688                 Assert.AreEqual ("Object", (val as ObjectMirror).Type.Name);
 689
 690                 // this on static methods
 691                 val = frame.GetThis ();
 692                 AssertValue (null, val);
 693
 694                 e = run_until ("arg3");
 695
 696                 frame = e.Thread.GetFrames () [0];
 697
 698                 // this
 699                 val = frame.GetThis ();
 700                 Assert.IsTrue (val is ObjectMirror);
 701                 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
 702
 703                 // objref in register
 704                 val = frame.GetArgument (0);
 705                 AssertValue ("BLA", val);
 706         }
 707
 708         [Test]
 709         public void Arrays () {
 710                 object val;
 711
 712                 var e = run_until ("o2");
 713
 714                 StackFrame frame = e.Thread.GetFrames () [0];
 715
 716                 // String[]
 717                 val = frame.GetArgument (0);
 718                 Assert.IsTrue (val is ArrayMirror);
 719                 ArrayMirror arr = val as ArrayMirror;
 720                 Assert.AreEqual (2, arr.Length);
 721                 AssertValue ("BAR", arr [0]);
 722                 AssertValue ("BAZ", arr [1]);
 723
 724                 var vals = arr.GetValues (0, 2);
 725                 Assert.AreEqual (2, vals.Count);
 726                 AssertValue ("BAR", vals [0]);
 727                 AssertValue ("BAZ", vals [1]);
 728
 729                 arr [0] = vm.RootDomain.CreateString ("ABC");
 730                 AssertValue ("ABC", arr [0]);
 731
 732                 arr [0] = vm.CreateValue (null);
 733                 AssertValue (null, arr [0]);
 734
 735                 arr.SetValues (0, new Value [] { vm.RootDomain.CreateString ("D1"), vm.RootDomain.CreateString ("D2") });
 736                 AssertValue ("D1", arr [0]);
 737                 AssertValue ("D2", arr [1]);
 738
 739                 // int
 740                 val = frame.GetArgument (1);
 741                 Assert.IsTrue (val is ArrayMirror);
 742                 arr = val as ArrayMirror;
 743                 Assert.AreEqual (2, arr.Length);
 744                 AssertValue (42, arr [0]);
 745                 AssertValue (43, arr [1]);
 746
 747                 // Argument checking
 748                 AssertThrows<IndexOutOfRangeException> (delegate () {
 749                                 val = arr [2];
 750                         });
 751
 752                 AssertThrows<IndexOutOfRangeException> (delegate () {
 753                                 val = arr [Int32.MinValue];
 754                         });
 755
 756                 AssertThrows<IndexOutOfRangeException> (delegate () {
 757                                 vals = arr.GetValues (0, 3);
 758                         });
 759
 760                 AssertThrows<IndexOutOfRangeException> (delegate () {
 761                                 arr [2] = vm.CreateValue (null);
 762                         });
 763
 764                 AssertThrows<IndexOutOfRangeException> (delegate () {
 765                                 arr [Int32.MinValue] = vm.CreateValue (null);
 766                         });
 767
 768                 AssertThrows<IndexOutOfRangeException> (delegate () {
 769                                 arr.SetValues (0, new Value [] { null, null, null });
 770                         });
 771
 772                 // Multidim arrays
 773                 val = frame.GetArgument (2);
 774                 Assert.IsTrue (val is ArrayMirror);
 775                 arr = val as ArrayMirror;
 776                 Assert.AreEqual (2, arr.Rank);
 777                 Assert.AreEqual (4, arr.Length);
 778                 Assert.AreEqual (2, arr.GetLength (0));
 779                 Assert.AreEqual (2, arr.GetLength (1));
 780                 Assert.AreEqual (0, arr.GetLowerBound (0));
 781                 Assert.AreEqual (0, arr.GetLowerBound (1));
 782                 vals = arr.GetValues (0, 4);
 783                 AssertValue (1, vals [0]);
 784                 AssertValue (2, vals [1]);
 785                 AssertValue (3, vals [2]);
 786                 AssertValue (4, vals [3]);
 787
 788                 val = frame.GetArgument (3);
 789                 Assert.IsTrue (val is ArrayMirror);
 790                 arr = val as ArrayMirror;
 791                 Assert.AreEqual (2, arr.Rank);
 792                 Assert.AreEqual (4, arr.Length);
 793                 Assert.AreEqual (2, arr.GetLength (0));
 794                 Assert.AreEqual (2, arr.GetLength (1));
 795                 Assert.AreEqual (1, arr.GetLowerBound (0));
 796                 Assert.AreEqual (3, arr.GetLowerBound (1));
 797
 798                 AssertThrows<ArgumentOutOfRangeException> (delegate () {
 799                                 arr.GetLength (-1);
 800                         });
 801                 AssertThrows<ArgumentOutOfRangeException> (delegate () {
 802                                 arr.GetLength (2);
 803                         });
 804
 805                 AssertThrows<ArgumentOutOfRangeException> (delegate () {
 806                                 arr.GetLowerBound (-1);
 807                         });
 808                 AssertThrows<ArgumentOutOfRangeException> (delegate () {
 809                                 arr.GetLowerBound (2);
 810                         });
 811
 812                 // arrays treated as generic collections
 813                 val = frame.GetArgument (4);
 814                 Assert.IsTrue (val is ArrayMirror);
 815                 arr = val as ArrayMirror;
 816         }
 817
 818         [Test]
 819         public void Object_GetValue () {
 820                 var e = run_until ("o1");
 821                 var frame = e.Thread.GetFrames () [0];
 822
 823                 object val = frame.GetThis ();
 824                 Assert.IsTrue (val is ObjectMirror);
 825                 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
 826                 ObjectMirror o = (val as ObjectMirror);
 827
 828                 TypeMirror t = o.Type;
 829
 830                 // object fields
 831                 object f = o.GetValue (t.GetField ("field_i"));
 832                 AssertValue (42, f);
 833                 f = o.GetValue (t.GetField ("field_s"));
 834                 AssertValue ("S", f);
 835                 f = o.GetValue (t.GetField ("field_enum"));
 836                 Assert.IsTrue (f is EnumMirror);
 837                 Assert.AreEqual (1, (f as EnumMirror).Value);
 838                 Assert.AreEqual ("B", (f as EnumMirror).StringValue);
 839
 840                 // Inherited object fields
 841                 TypeMirror parent = t.BaseType;
 842                 f = o.GetValue (parent.GetField ("base_field_i"));
 843                 AssertValue (43, f);
 844                 f = o.GetValue (parent.GetField ("base_field_s"));
 845                 AssertValue ("T", f);
 846
 847                 // Static fields
 848                 f = o.GetValue (o.Type.GetField ("static_i"));
 849                 AssertValue (55, f);
 850
 851                 // generic instances
 852                 ObjectMirror o2 = frame.GetValue (frame.Method.GetParameters ()[1]) as ObjectMirror;
 853                 Assert.AreEqual ("GClass`1", o2.Type.Name);
 854                 TypeMirror t2 = o2.Type;
 855                 f = o2.GetValue (t2.GetField ("field"));
 856                 AssertValue (42, f);
 857
 858                 ObjectMirror o3 = frame.GetValue (frame.Method.GetParameters ()[2]) as ObjectMirror;
 859                 Assert.AreEqual ("GClass`1", o3.Type.Name);
 860                 TypeMirror t3 = o3.Type;
 861                 f = o3.GetValue (t3.GetField ("field"));
 862                 AssertValue ("FOO", f);
 863
 864                 // Argument checking
 865                 AssertThrows<ArgumentNullException> (delegate () {
 866                         o.GetValue (null);
 867                         });
 868         }
 869
 870         [Test]
 871         public void Object_GetValues () {
 872                 var e = run_until ("o1");
 873                 var frame = e.Thread.GetFrames () [0];
 874
 875                 object val = frame.GetThis ();
 876                 Assert.IsTrue (val is ObjectMirror);
 877                 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
 878                 ObjectMirror o = (val as ObjectMirror);
 879
 880                 ObjectMirror val2 = frame.GetValue (frame.Method.GetParameters ()[0]) as ObjectMirror;
 881
 882                 TypeMirror t = o.Type;
 883
 884                 object[] vals = o.GetValues (new FieldInfoMirror [] { t.GetField ("field_i"), t.GetField ("field_s") });
 885                 object f = vals [0];
 886                 AssertValue (42, f);
 887                 f = vals [1];
 888                 AssertValue ("S", f);
 889
 890                 // Argument checking
 891                 AssertThrows<ArgumentNullException> (delegate () {
 892                         o.GetValues (null);
 893                         });
 894
 895                 AssertThrows<ArgumentNullException> (delegate () {
 896                         o.GetValues (new FieldInfoMirror [] { null });
 897                         });
 898
 899                 // field of another class
 900                 AssertThrows<ArgumentException> (delegate () {
 901                                 o.GetValue (val2.Type.GetField ("field_j"));
 902                         });
 903         }
 904
 905         void TestSetValue (ObjectMirror o, string field_name, object val) {
 906                 if (val is string)
 907                         o.SetValue (o.Type.GetField (field_name), vm.RootDomain.CreateString ((string)val));
 908                 else
 909                         o.SetValue (o.Type.GetField (field_name), vm.CreateValue (val));
 910                 Value f = o.GetValue (o.Type.GetField (field_name));
 911                 AssertValue (val, f);
 912         }
 913
 914         [Test]
 915         public void Object_SetValues () {
 916                 var e = run_until ("o1");
 917                 var frame = e.Thread.GetFrames () [0];
 918
 919                 object val = frame.GetThis ();
 920                 Assert.IsTrue (val is ObjectMirror);
 921                 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
 922                 ObjectMirror o = (val as ObjectMirror);
 923
 924                 ObjectMirror val2 = frame.GetValue (frame.Method.GetParameters ()[0]) as ObjectMirror;
 925
 926                 TestSetValue (o, "field_i", 22);
 927                 TestSetValue (o, "field_bool1", false);
 928                 TestSetValue (o, "field_bool2", true);
 929                 TestSetValue (o, "field_char", 'B');
 930                 TestSetValue (o, "field_byte", (byte)129);
 931                 TestSetValue (o, "field_sbyte", (sbyte)-33);
 932                 TestSetValue (o, "field_short", (short)(Int16.MaxValue - 5));
 933                 TestSetValue (o, "field_ushort", (ushort)(UInt16.MaxValue - 5));
 934                 TestSetValue (o, "field_long", Int64.MaxValue - 5);
 935                 TestSetValue (o, "field_ulong", (ulong)(UInt64.MaxValue - 5));
 936                 TestSetValue (o, "field_float", 6.28f);
 937                 TestSetValue (o, "field_double", 6.28);
 938                 TestSetValue (o, "static_i", 23);
 939                 TestSetValue (o, "field_s", "CDEF");
 940
 941                 Value f;
 942
 943                 // intptrs
 944                 f = o.GetValue (o.Type.GetField ("field_intptr"));
 945                 Assert.IsInstanceOfType (typeof (StructMirror), f);
 946                 AssertValue (Int32.MaxValue - 5, (f as StructMirror).Fields [0]);
 947
 948                 // enums
 949                 FieldInfoMirror field = o.Type.GetField ("field_enum");
 950                 f = o.GetValue (field);
 951                 (f as EnumMirror).Value = 5;
 952                 o.SetValue (field, f);
 953                 f = o.GetValue (field);
 954                 Assert.AreEqual (5, (f as EnumMirror).Value);
 955
 956                 // null
 957                 o.SetValue (o.Type.GetField ("field_s"), vm.CreateValue (null));
 958                 f = o.GetValue (o.Type.GetField ("field_s"));
 959                 AssertValue (null, f);
 960
 961                 // vtype instances
 962                 field = o.Type.GetField ("generic_field_struct");
 963                 f = o.GetValue (field);
 964                 o.SetValue (field, f);
 965
 966                 // nullables
 967                 field = o.Type.GetField ("field_nullable");
 968                 f = o.GetValue (field);
 969                 AssertValue (0, (f as StructMirror).Fields [0]);
 970                 AssertValue (false, (f as StructMirror).Fields [1]);
 971                 o.SetValue (field, vm.CreateValue (6));
 972                 f = o.GetValue (field);
 973                 AssertValue (6, (f as StructMirror).Fields [0]);
 974                 AssertValue (true, (f as StructMirror).Fields [1]);
 975                 o.SetValue (field, vm.CreateValue (null));
 976                 f = o.GetValue (field);
 977                 AssertValue (0, (f as StructMirror).Fields [0]);
 978                 AssertValue (false, (f as StructMirror).Fields [1]);
 979
 980                 // Argument checking
 981                 AssertThrows<ArgumentNullException> (delegate () {
 982                                 o.SetValues (null, new Value [0]);
 983                         });
 984
 985                 AssertThrows<ArgumentNullException> (delegate () {
 986                                 o.SetValues (new FieldInfoMirror [0], null);
 987                         });
 988
 989                 AssertThrows<ArgumentNullException> (delegate () {
 990                                 o.SetValues (new FieldInfoMirror [] { null }, new Value [1] { null });
 991                         });
 992
 993                 // vtype with a wrong type
 994                 AssertThrows<ArgumentException> (delegate () {
 995                                 o.SetValue (o.Type.GetField ("field_struct"), o.GetValue (o.Type.GetField ("field_enum")));
 996                         });
 997
 998                 // reference type not assignment compatible
 999                 AssertThrows<ArgumentException> (delegate () {
1000                                 o.SetValue (o.Type.GetField ("field_class"), o);
1001                         });
1002
1003                 // field of another class
1004                 AssertThrows<ArgumentException> (delegate () {
1005                                 o.SetValue (val2.Type.GetField ("field_j"), vm.CreateValue (1));
1006                         });
1007         }
1008
1009         [Test]
1010         public void Type_SetValue () {
1011                 var e = run_until ("o1");
1012                 var frame = e.Thread.GetFrames () [0];
1013                 Value f;
1014
1015                 object val = frame.GetThis ();
1016                 Assert.IsTrue (val is ObjectMirror);
1017                 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
1018                 ObjectMirror o = (val as ObjectMirror);
1019
1020                 ObjectMirror val2 = frame.GetValue (frame.Method.GetParameters ()[0]) as ObjectMirror;
1021
1022                 o.Type.SetValue (o.Type.GetField ("static_i"), vm.CreateValue (55));
1023                 f = o.Type.GetValue (o.Type.GetField ("static_i"));
1024                 AssertValue (55, f);
1025
1026                 o.Type.SetValue (o.Type.GetField ("static_s"), vm.RootDomain.CreateString ("B"));
1027                 f = o.Type.GetValue (o.Type.GetField ("static_s"));
1028                 AssertValue ("B", f);
1029
1030                 // Argument checking
1031                 AssertThrows<ArgumentNullException> (delegate () {
1032                                 o.Type.SetValue (null, vm.CreateValue (0));
1033                         });
1034
1035                 AssertThrows<ArgumentNullException> (delegate () {
1036                                 o.Type.SetValue (o.Type.GetField ("static_i"), null);
1037                         });
1038
1039                 // field of another class
1040                 AssertThrows<ArgumentException> (delegate () {
1041                                 o.SetValue (val2.Type.GetField ("field_j"), vm.CreateValue (1));
1042                         });
1043         }
1044
1045         [Test]
1046         public void TypeInfo () {
1047                 Event e = run_until ("ti2");
1048                 StackFrame frame = e.Thread.GetFrames () [0];
1049
1050                 TypeMirror t;
1051
1052                 // Array types
1053                 t = frame.Method.GetParameters ()[0].ParameterType;
1054
1055                 Assert.AreEqual ("String[]", t.Name);
1056                 Assert.AreEqual ("string[]", t.CSharpName);
1057                 Assert.AreEqual ("Array", t.BaseType.Name);
1058                 Assert.AreEqual (true, t.HasElementType);
1059                 Assert.AreEqual (true, t.IsArray);
1060                 Assert.AreEqual (1, t.GetArrayRank ());
1061                 Assert.AreEqual ("String", t.GetElementType ().Name);
1062
1063                 t = frame.Method.GetParameters ()[2].ParameterType;
1064
1065                 Assert.AreEqual ("Int32[,]", t.Name);
1066                 // FIXME:
1067                 //Assert.AreEqual ("int[,]", t.CSharpName);
1068                 Assert.AreEqual ("Array", t.BaseType.Name);
1069                 Assert.AreEqual (true, t.HasElementType);
1070                 Assert.AreEqual (true, t.IsArray);
1071                 Assert.AreEqual (2, t.GetArrayRank ());
1072                 Assert.AreEqual ("Int32", t.GetElementType ().Name);
1073
1074                 // Byref types
1075                 t = frame.Method.GetParameters ()[3].ParameterType;
1076                 // FIXME:
1077                 //Assert.AreEqual ("Int32&", t.Name);
1078                 //Assert.AreEqual (true, t.IsByRef);
1079                 //Assert.AreEqual (true, t.HasElementType);
1080
1081                 // Pointer types
1082                 t = frame.Method.GetParameters ()[4].ParameterType;
1083                 // FIXME:
1084                 //Assert.AreEqual ("Int32*", t.Name);
1085                 Assert.AreEqual (true, t.IsPointer);
1086                 Assert.AreEqual (true, t.HasElementType);
1087                 Assert.AreEqual ("Int32", t.GetElementType ().Name);
1088                 Assert.AreEqual (false, t.IsPrimitive);
1089
1090                 // primitive types
1091                 t = frame.Method.GetParameters ()[5].ParameterType;
1092                 Assert.AreEqual (true, t.IsPrimitive);
1093
1094                 // value types
1095                 t = frame.Method.GetParameters ()[6].ParameterType;
1096                 Assert.AreEqual ("AStruct", t.Name);
1097                 Assert.AreEqual (false, t.IsPrimitive);
1098                 Assert.AreEqual (true, t.IsValueType);
1099                 Assert.AreEqual (false, t.IsClass);
1100
1101                 // reference types
1102                 t = frame.Method.GetParameters ()[7].ParameterType;
1103                 Assert.AreEqual ("Tests", t.Name);
1104                 var nested = (from nt in t.GetNestedTypes () where nt.IsNestedPublic select nt).ToArray ();
1105                 Assert.AreEqual (1, nested.Length);
1106                 Assert.AreEqual ("NestedClass", nested [0].Name);
1107                 Assert.IsTrue (t.BaseType.IsAssignableFrom (t));
1108                 Assert.IsTrue (!t.IsAssignableFrom (t.BaseType));
1109
1110                 // generic instances
1111                 t = frame.Method.GetParameters ()[9].ParameterType;
1112                 Assert.AreEqual ("GClass`1", t.Name);
1113                 Assert.IsTrue (t.IsGenericType);
1114                 Assert.IsFalse (t.IsGenericTypeDefinition);
1115
1116                 var args = t.GetGenericArguments ();
1117                 Assert.AreEqual (1, args.Length);
1118                 Assert.AreEqual ("Int32", args [0].Name);
1119
1120                 // generic type definitions
1121                 var gtd = t.GetGenericTypeDefinition ();
1122                 Assert.AreEqual ("GClass`1", gtd.Name);
1123                 Assert.IsTrue (gtd.IsGenericType);
1124                 Assert.IsTrue (gtd.IsGenericTypeDefinition);
1125                 Assert.AreEqual (gtd, gtd.GetGenericTypeDefinition ());
1126
1127                 args = gtd.GetGenericArguments ();
1128                 Assert.AreEqual (1, args.Length);
1129                 Assert.AreEqual ("T", args [0].Name);
1130
1131                 // enums
1132                 t = frame.Method.GetParameters ()[10].ParameterType;
1133                 Assert.AreEqual ("AnEnum", t.Name);
1134                 Assert.IsTrue (t.IsEnum);
1135                 Assert.AreEqual ("Int32", t.EnumUnderlyingType.Name);
1136
1137                 // properties
1138                 t = frame.Method.GetParameters ()[7].ParameterType;
1139
1140                 var props = t.GetProperties ();
1141                 Assert.AreEqual (3, props.Length);
1142                 foreach (PropertyInfoMirror prop in props) {
1143                         ParameterInfoMirror[] indexes = prop.GetIndexParameters ();
1144
1145                         if (prop.Name == "IntProperty") {
1146                                 Assert.AreEqual ("Int32", prop.PropertyType.Name);
1147                                 Assert.AreEqual ("get_IntProperty", prop.GetGetMethod ().Name);
1148                                 Assert.AreEqual ("set_IntProperty", prop.GetSetMethod ().Name);
1149                                 Assert.AreEqual (0, indexes.Length);
1150                         } else if (prop.Name == "ReadOnlyProperty") {
1151                                 Assert.AreEqual ("Int32", prop.PropertyType.Name);
1152                                 Assert.AreEqual ("get_ReadOnlyProperty", prop.GetGetMethod ().Name);
1153                                 Assert.AreEqual (null, prop.GetSetMethod ());
1154                                 Assert.AreEqual (0, indexes.Length);
1155                         } else if (prop.Name == "IndexedProperty") {
1156                                 Assert.AreEqual (1, indexes.Length);
1157                                 Assert.AreEqual ("Int32", indexes [0].ParameterType.Name);
1158                         }
1159                 }
1160
1161                 // custom attributes
1162                 t = frame.Method.GetParameters ()[8].ParameterType;
1163                 Assert.AreEqual ("Tests2", t.Name);
1164                 var attrs = t.GetCustomAttributes (true);
1165                 Assert.AreEqual (5, attrs.Length);
1166                 foreach (var attr in attrs) {
1167                         if (attr.Constructor.DeclaringType.Name == "DebuggerDisplayAttribute") {
1168                                 Assert.AreEqual (1, attr.ConstructorArguments.Count);
1169                                 Assert.AreEqual ("Tests", attr.ConstructorArguments [0].Value);
1170                                 Assert.AreEqual (2, attr.NamedArguments.Count);
1171                                 Assert.AreEqual ("Name", attr.NamedArguments [0].Property.Name);
1172                                 Assert.AreEqual ("FOO", attr.NamedArguments [0].TypedValue.Value);
1173                                 Assert.AreEqual ("Target", attr.NamedArguments [1].Property.Name);
1174                                 Assert.IsInstanceOfType (typeof (TypeMirror), attr.NamedArguments [1].TypedValue.Value);
1175                                 Assert.AreEqual ("Int32", (attr.NamedArguments [1].TypedValue.Value as TypeMirror).Name);
1176                         } else if (attr.Constructor.DeclaringType.Name == "DebuggerTypeProxyAttribute") {
1177                                 Assert.AreEqual (1, attr.ConstructorArguments.Count);
1178                                 Assert.IsInstanceOfType (typeof (TypeMirror), attr.ConstructorArguments [0].Value);
1179                                 Assert.AreEqual ("Tests", (attr.ConstructorArguments [0].Value as TypeMirror).Name);
1180                         } else if (attr.Constructor.DeclaringType.Name == "BAttribute") {
1181                                 Assert.AreEqual (2, attr.NamedArguments.Count);
1182                                 Assert.AreEqual ("afield", attr.NamedArguments [0].Field.Name);
1183                                 Assert.AreEqual ("bfield", attr.NamedArguments [1].Field.Name);
1184                         } else if (attr.Constructor.DeclaringType.Name == "ClassInterfaceAttribute") {
1185                                 // inherited from System.Object
1186                                 //} else if (attr.Constructor.DeclaringType.Name == "Serializable") {
1187                                 // inherited from System.Object
1188                         } else if (attr.Constructor.DeclaringType.Name == "ComVisibleAttribute") {
1189                                 // inherited from System.Object
1190                         } else {
1191                                 Assert.Fail (attr.Constructor.DeclaringType.Name);
1192                         }
1193                 }
1194
1195                 var assembly = entry_point.DeclaringType.Assembly;
1196                 var type = assembly.GetType ("Tests4");
1197                 Assert.IsFalse (type.IsInitialized);
1198         }
1199
1200         [Test]
1201         public void FieldInfo () {
1202                 Event e = run_until ("ti2");
1203                 StackFrame frame = e.Thread.GetFrames () [0];
1204
1205                 TypeMirror t;
1206
1207                 t = frame.Method.GetParameters ()[8].ParameterType;
1208                 Assert.AreEqual ("Tests2", t.Name);
1209
1210                 var fi = t.GetField ("field_j");
1211                 var attrs = fi.GetCustomAttributes (true);
1212                 Assert.AreEqual (1, attrs.Length);
1213                 var attr = attrs [0];
1214                 Assert.AreEqual ("DebuggerBrowsableAttribute", attr.Constructor.DeclaringType.Name);
1215                 Assert.AreEqual (1, attr.ConstructorArguments.Count);
1216                 Assert.IsInstanceOfType (typeof (EnumMirror), attr.ConstructorArguments [0].Value);
1217                 Assert.AreEqual ((int)System.Diagnostics.DebuggerBrowsableState.Collapsed, (attr.ConstructorArguments [0].Value as EnumMirror).Value);
1218         }
1219
1220         [Test]
1221         public void PropertyInfo () {
1222                 Event e = run_until ("ti2");
1223                 StackFrame frame = e.Thread.GetFrames () [0];
1224
1225                 TypeMirror t;
1226
1227                 t = frame.Method.GetParameters ()[8].ParameterType;
1228                 Assert.AreEqual ("Tests2", t.Name);
1229
1230                 var pi = t.GetProperty ("AProperty");
1231                 var attrs = pi.GetCustomAttributes (true);
1232                 Assert.AreEqual (1, attrs.Length);
1233                 var attr = attrs [0];
1234                 Assert.AreEqual ("DebuggerBrowsableAttribute", attr.Constructor.DeclaringType.Name);
1235                 Assert.AreEqual (1, attr.ConstructorArguments.Count);
1236                 Assert.IsInstanceOfType (typeof (EnumMirror), attr.ConstructorArguments [0].Value);
1237                 Assert.AreEqual ((int)System.Diagnostics.DebuggerBrowsableState.Collapsed, (attr.ConstructorArguments [0].Value as EnumMirror).Value);
1238         }
1239
1240         [Test]
1241         [Category ("only5")]
1242         public void Type_GetValue () {
1243                 Event e = run_until ("o1");
1244                 StackFrame frame = e.Thread.GetFrames () [0];
1245
1246                 ObjectMirror o = (frame.GetThis () as ObjectMirror);
1247
1248                 TypeMirror t = o.Type;
1249
1250                 ObjectMirror val2 = frame.GetValue (frame.Method.GetParameters ()[0]) as ObjectMirror;
1251
1252                 // static fields
1253                 object f = t.GetValue (o.Type.GetField ("static_i"));
1254                 AssertValue (55, f);
1255
1256                 f = t.GetValue (o.Type.GetField ("static_s"));
1257                 AssertValue ("A", f);
1258
1259                 // literal static fields
1260                 f = t.GetValue (o.Type.GetField ("literal_i"));
1261                 AssertValue (56, f);
1262
1263                 f = t.GetValue (o.Type.GetField ("literal_s"));
1264                 AssertValue ("B", f);
1265
1266                 // Inherited static fields
1267                 TypeMirror parent = t.BaseType;
1268                 f = t.GetValue (parent.GetField ("base_static_i"));
1269                 AssertValue (57, f);
1270
1271                 f = t.GetValue (parent.GetField ("base_static_s"));
1272                 AssertValue ("C", f);
1273
1274                 // thread static field
1275                 f = t.GetValue (t.GetField ("tls_i"), e.Thread);
1276                 AssertValue (42, f);
1277
1278                 // Argument checking
1279                 AssertThrows<ArgumentNullException> (delegate () {
1280                         t.GetValue (null);
1281                         });
1282
1283                 // instance fields
1284                 AssertThrows<ArgumentException> (delegate () {
1285                         t.GetValue (o.Type.GetField ("field_i"));
1286                         });
1287
1288                 // field on another type
1289                 AssertThrows<ArgumentException> (delegate () {
1290                                 t.GetValue (val2.Type.GetField ("static_field_j"));
1291                         });
1292
1293                 // special static field
1294                 AssertThrows<ArgumentException> (delegate () {
1295                                 t.GetValue (t.GetField ("tls_i"));
1296                         });
1297         }
1298
1299         [Test]
1300         public void Type_GetValues () {
1301                 Event e = run_until ("o1");
1302                 StackFrame frame = e.Thread.GetFrames () [0];
1303
1304                 ObjectMirror o = (frame.GetThis () as ObjectMirror);
1305
1306                 TypeMirror t = o.Type;
1307
1308                 // static fields
1309                 object[] vals = t.GetValues (new FieldInfoMirror [] { t.GetField ("static_i"), t.GetField ("static_s") });
1310                 object f = vals [0];
1311                 AssertValue (55, f);
1312
1313                 f = vals [1];
1314                 AssertValue ("A", f);
1315
1316                 // Argument checking
1317                 AssertThrows<ArgumentNullException> (delegate () {
1318                         t.GetValues (null);
1319                         });
1320
1321                 AssertThrows<ArgumentNullException> (delegate () {
1322                         t.GetValues (new FieldInfoMirror [] { null });
1323                         });
1324         }
1325
1326         [Test]
1327         public void ObjRefs () {
1328                 Event e = run_until ("objrefs1");
1329                 StackFrame frame = e.Thread.GetFrames () [0];
1330
1331                 ObjectMirror o = frame.GetThis () as ObjectMirror;
1332                 ObjectMirror child = o.GetValue (o.Type.GetField ("child")) as ObjectMirror;
1333
1334                 Assert.IsTrue (child.Address != 0);
1335
1336                 // Check that object references are internalized correctly
1337                 Assert.AreEqual (o, frame.GetThis ());
1338
1339                 run_until ("objrefs2");
1340
1341                 // child should be gc'd now
1342                 // This is not deterministic
1343                 //Assert.IsTrue (child.IsCollected);
1344
1345                 /*
1346                  * No longer works since Type is read eagerly
1347                  */
1348                 /*
1349                 AssertThrows<ObjectCollectedException> (delegate () {
1350                         TypeMirror t = child.Type;
1351                         });
1352                 */
1353                 /*
1354                 AssertThrows<ObjectCollectedException> (delegate () {
1355                                 long addr = child.Address;
1356                         });
1357                 */
1358         }
1359
1360         [Test]
1361         public void Type_GetObject () {
1362                 Event e = run_until ("o1");
1363                 StackFrame frame = e.Thread.GetFrames () [0];
1364
1365                 ObjectMirror o = (frame.GetThis () as ObjectMirror);
1366
1367                 TypeMirror t = o.Type;
1368
1369                 Assert.AreEqual ("MonoType", t.GetTypeObject ().Type.Name);
1370         }
1371
1372         [Test]
1373         public void VTypes () {
1374                 Event e = run_until ("vtypes1");
1375                 StackFrame frame = e.Thread.GetFrames () [0];
1376
1377                 // vtypes as fields
1378                 ObjectMirror o = frame.GetThis () as ObjectMirror;
1379                 var obj = o.GetValue (o.Type.GetField ("field_struct"));
1380                 Assert.IsTrue (obj is StructMirror);
1381                 var s = obj as StructMirror;
1382                 Assert.AreEqual ("AStruct", s.Type.Name);
1383                 AssertValue (42, s ["i"]);
1384                 obj = s ["s"];
1385                 AssertValue ("S", obj);
1386                 AssertValue (43, s ["k"]);
1387                 obj = o.GetValue (o.Type.GetField ("field_boxed_struct"));
1388                 Assert.IsTrue (obj is StructMirror);
1389                 s = obj as StructMirror;
1390                 Assert.AreEqual ("AStruct", s.Type.Name);
1391                 AssertValue (42, s ["i"]);
1392
1393                 // Check decoding of nested structs (#14942)
1394                 obj = o.GetValue (o.Type.GetField ("nested_struct"));
1395                 o.SetValue (o.Type.GetField ("nested_struct"), obj);
1396
1397                 // Check round tripping of boxed struct fields (#12354)
1398                 obj = o.GetValue (o.Type.GetField ("boxed_struct_field"));
1399                 o.SetValue (o.Type.GetField ("boxed_struct_field"), obj);
1400                 obj = o.GetValue (o.Type.GetField ("boxed_struct_field"));
1401                 s = obj as StructMirror;
1402                 AssertValue (1, s ["key"]);
1403                 obj = s ["value"];
1404                 Assert.IsTrue (obj is StructMirror);
1405                 s = obj as StructMirror;
1406                 AssertValue (42, s ["m_value"]);
1407
1408                 // vtypes as arguments
1409                 s = frame.GetArgument (0) as StructMirror;
1410                 AssertValue (44, s ["i"]);
1411                 obj = s ["s"];
1412                 AssertValue ("T", obj);
1413                 AssertValue (45, s ["k"]);
1414
1415                 // vtypes as array entries
1416                 var arr = frame.GetArgument (1) as ArrayMirror;
1417                 obj = arr [0];
1418                 Assert.IsTrue (obj is StructMirror);
1419                 s = obj as StructMirror;
1420                 AssertValue (1, s ["i"]);
1421                 AssertValue ("S1", s ["s"]);
1422                 obj = arr [1];
1423                 Assert.IsTrue (obj is StructMirror);
1424                 s = obj as StructMirror;
1425                 AssertValue (2, s ["i"]);
1426                 AssertValue ("S2", s ["s"]);
1427
1428                 // Argument checking
1429                 s = frame.GetArgument (0) as StructMirror;
1430                 AssertThrows<ArgumentException> (delegate () {
1431                                 obj = s ["FOO"];
1432                         });
1433
1434                 // generic vtype instances
1435                 o = frame.GetThis () as ObjectMirror;
1436                 obj = o.GetValue (o.Type.GetField ("generic_field_struct"));
1437                 Assert.IsTrue (obj is StructMirror);
1438                 s = obj as StructMirror;
1439                 Assert.AreEqual ("GStruct`1", s.Type.Name);
1440                 AssertValue (42, s ["i"]);
1441
1442                 // this on vtype methods
1443                 e = run_until ("vtypes2");
1444                 e = step_until (e.Thread, "foo");
1445
1446                 frame = e.Thread.GetFrames () [0];
1447
1448                 Assert.AreEqual ("foo", (e as StepEvent).Method.Name);
1449                 obj = frame.GetThis ();
1450
1451                 Assert.IsTrue (obj is StructMirror);
1452                 s = obj as StructMirror;
1453                 AssertValue (44, s ["i"]);
1454                 AssertValue ("T", s ["s"]);
1455                 AssertValue (45, s ["k"]);
1456
1457                 // this on static vtype methods
1458                 e = run_until ("vtypes3");
1459                 e = step_until (e.Thread, "static_foo");
1460
1461                 frame = e.Thread.GetFrames () [0];
1462
1463                 Assert.AreEqual ("static_foo", (e as StepEvent).Method.Name);
1464                 obj = frame.GetThis ();
1465                 AssertValue (null, obj);
1466
1467                 // vtypes which reference themselves recursively
1468                 e = run_until ("vtypes4_2");
1469                 frame = e.Thread.GetFrames () [0];
1470
1471                 Assert.IsTrue (frame.GetArgument (0) is StructMirror);
1472         }
1473
1474         [Test]
1475         public void AssemblyInfo () {
1476                 Event e = run_until ("single_stepping");
1477
1478                 StackFrame frame = e.Thread.GetFrames () [0];
1479
1480                 var aname = frame.Method.DeclaringType.Assembly.GetName ();
1481                 Assert.AreEqual ("dtest-app, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", aname.ToString ());
1482
1483                 ModuleMirror m = frame.Method.DeclaringType.Module;
1484
1485                 Assert.AreEqual ("dtest-app.exe", m.Name);
1486                 Assert.AreEqual ("dtest-app.exe", m.ScopeName);
1487                 Assert.IsTrue (m.FullyQualifiedName.IndexOf ("dtest-app.exe") != -1);
1488                 Guid guid = m.ModuleVersionId;
1489                 Assert.AreEqual (frame.Method.DeclaringType.Assembly, m.Assembly);
1490                 Assert.AreEqual (frame.Method.DeclaringType.Assembly.ManifestModule, m);
1491
1492                 // This is no longer true on 4.0
1493                 //Assert.AreEqual ("Assembly", frame.Method.DeclaringType.Assembly.GetAssemblyObject ().Type.Name);
1494
1495                 TypeMirror t = vm.RootDomain.Corlib.GetType ("System.Diagnostics.DebuggerDisplayAttribute");
1496                 Assert.AreEqual ("DebuggerDisplayAttribute", t.Name);
1497         }
1498
1499         [Test]
1500         public void LocalsInfo () {
1501                 Event e = run_until ("locals2");
1502
1503                 StackFrame frame = e.Thread.GetFrames () [0];
1504
1505                 var locals = frame.Method.GetLocals ();
1506                 Assert.AreEqual (8, locals.Length);
1507                 for (int i = 0; i < 8; ++i) {
1508                         if (locals [i].Name == "args") {
1509                                 Assert.IsTrue (locals [i].IsArg);
1510                                 Assert.AreEqual ("String[]", locals [i].Type.Name);
1511                         } else if (locals [i].Name == "arg") {
1512                                 Assert.IsTrue (locals [i].IsArg);
1513                                 Assert.AreEqual ("Int32", locals [i].Type.Name);
1514                         } else if (locals [i].Name == "i") {
1515                                 Assert.IsFalse (locals [i].IsArg);
1516                                 Assert.AreEqual ("Int64", locals [i].Type.Name);
1517                         } else if (locals [i].Name == "j") {
1518                                 Assert.IsFalse (locals [i].IsArg);
1519                                 Assert.AreEqual ("Int32", locals [i].Type.Name);
1520                         } else if (locals [i].Name == "s") {
1521                                 Assert.IsFalse (locals [i].IsArg);
1522                                 Assert.AreEqual ("String", locals [i].Type.Name);
1523                         } else if (locals [i].Name == "t") {
1524                                 // gshared
1525                                 Assert.IsTrue (locals [i].IsArg);
1526                                 Assert.AreEqual ("String", locals [i].Type.Name);
1527                         } else if (locals [i].Name == "rs") {
1528                                 Assert.IsTrue (locals [i].IsArg);
1529                                 Assert.AreEqual ("String", locals [i].Type.Name);
1530                         } else if (locals [i].Name == "astruct") {
1531                         } else {
1532                                 Assert.Fail ();
1533                         }
1534                 }
1535         }
1536
1537         Event step_once () {
1538                 vm.Resume ();
1539                 var e = GetNextEvent ();
1540                 Assert.IsTrue (e is StepEvent);
1541                 return e;
1542         }
1543
1544         Event step_into () {
1545                 step_req.Disable ();
1546                 step_req.Depth = StepDepth.Into;
1547                 step_req.Enable ();
1548                 return step_once ();
1549         }
1550
1551         Event step_over () {
1552                 step_req.Disable ();
1553                 step_req.Depth = StepDepth.Over;
1554                 step_req.Enable ();
1555                 return step_once ();
1556         }
1557
1558         Event step_out () {
1559                 step_req.Disable ();
1560                 step_req.Depth = StepDepth.Out;
1561                 step_req.Enable ();
1562                 return step_once ();
1563         }
1564
1565         [Test]
1566         public void Locals () {
1567                 var be = run_until ("locals1");
1568
1569                 StackFrame frame = be.Thread.GetFrames () [0];
1570                 MethodMirror m1 = frame.Method;
1571
1572                 // Compiler generated byref local
1573                 foreach (var l in m1.GetLocals ()) {
1574                         // The byval flag is hidden from the type
1575                         if (l.Name != "ri" && l.Type.Name == "Double")
1576                                 AssertValue (null, frame.GetValue (l));
1577                 }
1578
1579                 be = run_until ("locals2");
1580
1581                 frame = be.Thread.GetFrames () [0];
1582
1583                 object val = frame.GetValue (frame.Method.GetLocal ("i"));
1584                 AssertValue (0, val);
1585
1586                 var req = create_step (be);
1587                 req.Enable ();
1588
1589                 // Skip nop
1590                 step_once ();
1591
1592                 // Execute i = 42
1593                 var e = step_once ();
1594                 Assert.AreEqual ("locals2", (e as StepEvent).Method.Name);
1595
1596                 // Execute s = "AB";
1597                 e = step_once ();
1598                 Assert.AreEqual ("locals2", (e as StepEvent).Method.Name);
1599
1600                 frame = e.Thread.GetFrames () [0];
1601
1602                 val = frame.GetValue (frame.Method.GetLocal ("i"));
1603                 AssertValue (42, val);
1604
1605                 LocalVariable[] locals = frame.Method.GetLocals ();
1606                 var vals = frame.GetValues (locals);
1607                 Assert.AreEqual (locals.Length, vals.Length);
1608                 for (int i = 0; i < locals.Length; ++i) {
1609                         if (locals [i].Name == "i")
1610                                 AssertValue (42, vals [i]);
1611                         if (locals [i].Name == "s")
1612                                 AssertValue ("AB", vals [i]);
1613                         if (locals [i].Name == "t")
1614                                 AssertValue ("ABC", vals [i]);
1615                 }
1616
1617                 // Argument checking
1618
1619                 // GetValue () null
1620                 AssertThrows<ArgumentNullException> (delegate () {
1621                                 frame.GetValue ((LocalVariable)null);
1622                         });
1623                 // GetValue () local from another method
1624                 AssertThrows<ArgumentException> (delegate () {
1625                                 frame.GetValue (m1.GetLocal ("foo"));
1626                         });
1627
1628                 // GetValue () null
1629                 AssertThrows<ArgumentNullException> (delegate () {
1630                                 frame.GetValue ((ParameterInfoMirror)null);
1631                         });
1632                 // GetValue () local from another method
1633                 AssertThrows<ArgumentException> (delegate () {
1634                                 frame.GetValue (m1.GetParameters ()[0]);
1635                         });
1636
1637                 // GetValues () null
1638                 AssertThrows<ArgumentNullException> (delegate () {
1639                                 frame.GetValues (null);
1640                         });
1641                 // GetValues () embedded null
1642                 AssertThrows<ArgumentNullException> (delegate () {
1643                                 frame.GetValues (new LocalVariable [] { null });
1644                         });
1645                 // GetValues () local from another method
1646                 AssertThrows<ArgumentException> (delegate () {
1647                                 frame.GetValues (new LocalVariable [] { m1.GetLocal ("foo") });
1648                         });
1649                 // return value
1650                 AssertThrows<ArgumentException> (delegate () {
1651                                 val = frame.GetValue (frame.Method.ReturnParameter);
1652                         });
1653
1654                 // invalid stack frames
1655                 vm.Resume ();
1656                 e = GetNextEvent ();
1657                 Assert.IsTrue (e is StepEvent);
1658                 Assert.AreEqual ("locals2", (e as StepEvent).Method.Name);
1659
1660                 AssertThrows<InvalidStackFrameException> (delegate () {
1661                                 frame.GetValue (frame.Method.GetLocal ("i"));
1662                         });
1663
1664                 req.Disable ();
1665
1666                 // gsharedvt
1667                 be = run_until ("locals7");
1668
1669                 req = create_step (be);
1670                 req.Enable ();
1671
1672                 // Skip nop
1673                 e = step_once ();
1674
1675                 // Test that locals are initialized
1676                 frame = e.Thread.GetFrames () [0];
1677                 val = frame.GetValue (frame.Method.GetLocal ("t"));
1678                 AssertValue (0, val);
1679
1680                 // Execute t = arg
1681                 e = step_once ();
1682                 Assert.AreEqual ("locals7", (e as StepEvent).Method.Name);
1683
1684                 // Execute t2 = t
1685                 e = step_once ();
1686                 Assert.AreEqual ("locals7", (e as StepEvent).Method.Name);
1687
1688                 frame = e.Thread.GetFrames () [0];
1689                 val = frame.GetValue (frame.Method.GetParameters ()[0]);
1690                 AssertValue (22, val);
1691                 val = frame.GetValue (frame.Method.GetLocal ("t"));
1692                 AssertValue (22, val);
1693                 val = frame.GetValue (frame.Method.GetLocal ("t2"));
1694                 AssertValue (22, val);
1695         }
1696
1697         [Test]
1698         public void GetVisibleVariables () {
1699                 Event e = run_until ("locals4");
1700
1701                 // First scope
1702                 var locals = e.Thread.GetFrames ()[1].GetVisibleVariables ();
1703                 Assert.AreEqual (2, locals.Count);
1704                 var loc = locals.First (l => l.Name == "i");
1705                 Assert.AreEqual ("Int64", loc.Type.Name);
1706                 loc = locals.First (l => l.Name == "s");
1707                 Assert.AreEqual ("String", loc.Type.Name);
1708
1709                 loc = e.Thread.GetFrames ()[1].GetVisibleVariableByName ("i");
1710                 Assert.AreEqual ("i", loc.Name);
1711                 Assert.AreEqual ("Int64", loc.Type.Name);
1712
1713                 e = run_until ("locals5");
1714
1715                 // Second scope
1716                 locals = e.Thread.GetFrames ()[1].GetVisibleVariables ();
1717                 Assert.AreEqual (2, locals.Count);
1718                 loc = locals.First (l => l.Name == "i");
1719                 Assert.AreEqual ("String", loc.Type.Name);
1720                 loc = locals.First (l => l.Name == "s");
1721                 Assert.AreEqual ("String", loc.Type.Name);
1722
1723                 loc = e.Thread.GetFrames ()[1].GetVisibleVariableByName ("i");
1724                 Assert.AreEqual ("i", loc.Name);
1725                 Assert.AreEqual ("String", loc.Type.Name);
1726
1727                 // Variable in another scope
1728                 loc = e.Thread.GetFrames ()[1].GetVisibleVariableByName ("j");
1729                 Assert.IsNull (loc);
1730         }
1731
1732         [Test]
1733         public void Exit () {
1734                 run_until ("Main");
1735
1736                 vm.Exit (5);
1737
1738                 var e = GetNextEvent ();
1739                 Assert.IsInstanceOfType (typeof (VMDeathEvent), e);
1740
1741                 Assert.AreEqual (5, (e as VMDeathEvent).ExitCode);
1742
1743                 var p = vm.Process;
1744                 /* Could be a remote vm with no process */
1745                 if (p != null) {
1746                         p.WaitForExit ();
1747                         Assert.AreEqual (5, p.ExitCode);
1748
1749                         // error handling
1750                         AssertThrows<VMDisconnectedException> (delegate () {
1751                                         vm.Resume ();
1752                                 });
1753                 }
1754
1755                 vm = null;
1756         }
1757
1758         [Test]
1759         public void Dispose () {
1760                 run_until ("Main");
1761
1762                 vm.Detach ();
1763
1764                 var e = GetNextEvent ();
1765                 Assert.IsInstanceOfType (typeof (VMDisconnectEvent), e);
1766
1767                 var p = vm.Process;
1768                 /* Could be a remote vm with no process */
1769                 if (p != null) {
1770                         p.WaitForExit ();
1771                         Assert.AreEqual (3, p.ExitCode);
1772
1773                         // error handling
1774                         AssertThrows<VMDisconnectedException> (delegate () {
1775                                         vm.Resume ();
1776                                 });
1777                 }
1778
1779                 vm = null;
1780         }
1781
1782         [Test]
1783         public void ColumnNumbers () {
1784                 Event e = run_until ("line_numbers");
1785
1786                 // FIXME: Merge this with LineNumbers () when its fixed
1787
1788                 step_req = create_step (e);
1789                 step_req.Depth = StepDepth.Into;
1790                 step_req.Enable ();
1791
1792                 Location l;
1793
1794                 while (true) {
1795                         vm.Resume ();
1796
1797                         e = GetNextEvent ();
1798                         Assert.IsTrue (e is StepEvent);
1799                         if (e.Thread.GetFrames ()[0].Method.Name == "ln1")
1800                                 break;
1801                 }
1802
1803                 // Do an additional step over so we are not on the beginning line of the method
1804                 step_req.Disable ();
1805                 step_req.Depth = StepDepth.Over;
1806                 step_req.Enable ();
1807                 vm.Resume ();
1808                 e = GetNextEvent ();
1809                 Assert.IsTrue (e is StepEvent);
1810
1811                 l = e.Thread.GetFrames ()[0].Location;
1812
1813                 Assert.AreEqual (3, l.ColumnNumber);
1814
1815                 step_req.Disable ();
1816         }
1817
1818         [Test]
1819         // Broken by mcs+runtime changes (#5438)
1820         [Category("NotWorking")]
1821         public void LineNumbers () {
1822                 Event e = run_until ("line_numbers");
1823
1824                 step_req = create_step (e);
1825                 step_req.Depth = StepDepth.Into;
1826                 step_req.Enable ();
1827
1828                 Location l;
1829
1830                 vm.Resume ();
1831
1832                 e = GetNextEvent ();
1833                 Assert.IsTrue (e is StepEvent);
1834
1835                 l = e.Thread.GetFrames ()[0].Location;
1836
1837                 Assert.IsTrue (l.SourceFile.IndexOf ("dtest-app.cs") != -1);
1838                 Assert.AreEqual ("ln1", l.Method.Name);
1839
1840                 // Check hash
1841                 using (FileStream fs = new FileStream (l.SourceFile, FileMode.Open, FileAccess.Read)) {
1842                         MD5 md5 = MD5.Create ();
1843                         var hash = md5.ComputeHash (fs);
1844
1845                         for (int i = 0; i < 16; ++i)
1846                                 Assert.AreEqual (hash [i], l.SourceFileHash [i]);
1847                 }
1848
1849                 int line_base = l.LineNumber;
1850
1851                 vm.Resume ();
1852                 e = GetNextEvent ();
1853                 Assert.IsTrue (e is StepEvent);
1854                 l = e.Thread.GetFrames ()[0].Location;
1855                 Assert.AreEqual ("ln2", l.Method.Name);
1856                 Assert.AreEqual (line_base + 6, l.LineNumber);
1857
1858                 vm.Resume ();
1859                 e = GetNextEvent ();
1860                 Assert.IsTrue (e is StepEvent);
1861                 l = e.Thread.GetFrames ()[0].Location;
1862                 Assert.AreEqual ("ln1", l.Method.Name);
1863                 Assert.AreEqual (line_base + 1, l.LineNumber);
1864
1865                 vm.Resume ();
1866                 e = GetNextEvent ();
1867                 Assert.IsTrue (e is StepEvent);
1868                 l = e.Thread.GetFrames ()[0].Location;
1869                 Assert.AreEqual ("ln3", l.Method.Name);
1870                 Assert.AreEqual (line_base + 11, l.LineNumber);
1871
1872                 vm.Resume ();
1873                 e = GetNextEvent ();
1874                 Assert.IsTrue (e is StepEvent);
1875                 l = e.Thread.GetFrames ()[0].Location;
1876                 Assert.AreEqual ("ln3", l.Method.Name);
1877                 Assert.IsTrue (l.SourceFile.EndsWith ("FOO"));
1878                 Assert.AreEqual (55, l.LineNumber);
1879
1880                 vm.Resume ();
1881                 e = GetNextEvent ();
1882                 Assert.IsTrue (e is StepEvent);
1883                 l = e.Thread.GetFrames ()[0].Location;
1884                 Assert.AreEqual ("ln1", l.Method.Name);
1885                 Assert.AreEqual (line_base + 2, l.LineNumber);
1886
1887                 // GetSourceFiles ()
1888                 string[] sources = l.Method.DeclaringType.GetSourceFiles ();
1889                 Assert.AreEqual (2, sources.Length);
1890                 Assert.AreEqual ("dtest-app.cs", sources [0]);
1891                 Assert.AreEqual ("FOO", sources [1]);
1892
1893                 sources = l.Method.DeclaringType.GetSourceFiles (true);
1894                 Assert.AreEqual (2, sources.Length);
1895                 Assert.IsTrue (sources [0].EndsWith ("dtest-app.cs"));
1896                 Assert.IsTrue (sources [1].EndsWith ("FOO"));
1897         }
1898
1899         [Test]
1900         public void Suspend () {
1901                 vm.Detach ();
1902
1903                 Start (new string [] { "dtest-app.exe", "suspend-test" });
1904
1905                 Event e = run_until ("suspend");
1906
1907                 ThreadMirror main = e.Thread;
1908
1909                 vm.Resume ();
1910
1911                 Thread.Sleep (100);
1912
1913                 vm.Suspend ();
1914
1915                 // The debuggee should be suspended while it is running the infinite loop
1916                 // in suspend ()
1917                 StackFrame frame = main.GetFrames ()[0];
1918                 Assert.AreEqual ("suspend", frame.Method.Name);
1919
1920                 vm.Resume ();
1921
1922                 // resuming when not suspended
1923                 AssertThrows<InvalidOperationException> (delegate () {
1924                                 vm.Resume ();
1925                         });
1926
1927                 vm.Exit (0);
1928
1929                 vm = null;
1930         }
1931
1932         [Test]
1933         public void AssemblyLoad () {
1934                 Event e = run_until ("assembly_load");
1935
1936                 var load_req = vm.CreateAssemblyLoadRequest ();
1937                 load_req.Enable ();
1938
1939                 vm.Resume ();
1940
1941                 e = GetNextEvent ();
1942                 Assert.IsInstanceOfType (typeof (AssemblyLoadEvent), e);
1943                 Assert.IsTrue ((e as AssemblyLoadEvent).Assembly.Location.EndsWith ("System.dll"));
1944
1945                 var frames = e.Thread.GetFrames ();
1946                 Assert.IsTrue (frames.Length > 0);
1947                 Assert.AreEqual ("assembly_load", frames [0].Method.Name);
1948         }
1949
1950         [Test]
1951         public void CreateValue () {
1952                 PrimitiveValue v;
1953
1954                 v = vm.CreateValue (1);
1955                 Assert.AreEqual (vm, v.VirtualMachine);
1956                 Assert.AreEqual (1, v.Value);
1957
1958                 v = vm.CreateValue (null);
1959                 Assert.AreEqual (vm, v.VirtualMachine);
1960                 Assert.AreEqual (null, v.Value);
1961
1962                 // Argument checking
1963                 AssertThrows <ArgumentException> (delegate () {
1964                                 v = vm.CreateValue ("FOO");
1965                         });
1966         }
1967
1968         [Test]
1969         public void CreateString () {
1970                 StringMirror s = vm.RootDomain.CreateString ("ABC");
1971
1972                 Assert.AreEqual (vm, s.VirtualMachine);
1973                 Assert.AreEqual ("ABC", s.Value);
1974                 Assert.AreEqual (vm.RootDomain, s.Domain);
1975
1976                 // Long strings
1977                 StringBuilder sb = new StringBuilder ();
1978                 for (int i = 0; i < 1024; ++i)
1979                         sb.Append ('A');
1980                 s = vm.RootDomain.CreateString (sb.ToString ());
1981
1982                 // Argument checking
1983                 AssertThrows <ArgumentNullException> (delegate () {
1984                                 s = vm.RootDomain.CreateString (null);
1985                         });
1986         }
1987
1988         [Test]
1989         public void CreateBoxedValue () {
1990                 ObjectMirror o = vm.RootDomain.CreateBoxedValue (new PrimitiveValue (vm, 42));
1991
1992                 Assert.AreEqual ("Int32", o.Type.Name);
1993                 //AssertValue (42, m.GetValue (o.Type.GetField ("m_value")));
1994
1995                 // Argument checking
1996                 AssertThrows <ArgumentNullException> (delegate () {
1997                                 vm.RootDomain.CreateBoxedValue (null);
1998                         });
1999
2000                 AssertThrows <ArgumentException> (delegate () {
2001                                 vm.RootDomain.CreateBoxedValue (o);
2002                         });
2003         }
2004
2005         [Test]
2006         public void Invoke () {
2007                 Event e = run_until ("invoke1");
2008
2009                 StackFrame frame = e.Thread.GetFrames () [0];
2010
2011                 TypeMirror t = frame.Method.DeclaringType;
2012                 ObjectMirror this_obj = (ObjectMirror)frame.GetThis ();
2013
2014                 TypeMirror t2 = frame.Method.GetParameters ()[0].ParameterType;
2015
2016                 MethodMirror m;
2017                 Value v;
2018
2019                 // return void
2020                 m = t.GetMethod ("invoke_return_void");
2021                 v = this_obj.InvokeMethod (e.Thread, m, null);
2022                 Assert.IsNull (v);
2023
2024                 // return ref
2025                 m = t.GetMethod ("invoke_return_ref");
2026                 v = this_obj.InvokeMethod (e.Thread, m, null);
2027                 AssertValue ("ABC", v);
2028
2029                 // return null
2030                 m = t.GetMethod ("invoke_return_null");
2031                 v = this_obj.InvokeMethod (e.Thread, m, null);
2032                 AssertValue (null, v);
2033
2034                 // return primitive
2035                 m = t.GetMethod ("invoke_return_primitive");
2036                 v = this_obj.InvokeMethod (e.Thread, m, null);
2037                 AssertValue (42, v);
2038
2039                 // return nullable
2040                 m = t.GetMethod ("invoke_return_nullable");
2041                 v = this_obj.InvokeMethod (e.Thread, m, null);
2042                 Assert.IsInstanceOfType (typeof (StructMirror), v);
2043                 var s = v as StructMirror;
2044                 AssertValue (42, s.Fields [0]);
2045                 AssertValue (true, s.Fields [1]);
2046
2047                 // pass nullable as this
2048                 //m = vm.RootDomain.Corlib.GetType ("System.Object").GetMethod ("ToString");
2049                 m = s.Type.GetMethod ("ToString");
2050                 v = s.InvokeMethod (e.Thread, m, null);
2051
2052                 // return nullable null
2053                 m = t.GetMethod ("invoke_return_nullable_null");
2054                 v = this_obj.InvokeMethod (e.Thread, m, null);
2055                 Assert.IsInstanceOfType (typeof (StructMirror), v);
2056                 s = v as StructMirror;
2057                 AssertValue (0, s.Fields [0]);
2058                 AssertValue (false, s.Fields [1]);
2059
2060                 // pass nullable as this
2061                 //m = vm.RootDomain.Corlib.GetType ("System.Object").GetMethod ("ToString");
2062                 m = s.Type.GetMethod ("ToString");
2063                 v = s.InvokeMethod (e.Thread, m, null);
2064
2065                 // pass primitive
2066                 m = t.GetMethod ("invoke_pass_primitive");
2067                 Value[] args = new Value [] {
2068                         vm.CreateValue ((byte)Byte.MaxValue),
2069                         vm.CreateValue ((sbyte)SByte.MaxValue),
2070                         vm.CreateValue ((short)1),
2071                         vm.CreateValue ((ushort)1),
2072                         vm.CreateValue ((int)1),
2073                         vm.CreateValue ((uint)1),
2074                         vm.CreateValue ((long)1),
2075                         vm.CreateValue ((ulong)1),
2076                         vm.CreateValue ('A'),
2077                         vm.CreateValue (true),
2078                         vm.CreateValue (3.14f),
2079                         vm.CreateValue (3.14) };
2080
2081                 v = this_obj.InvokeMethod (e.Thread, m, args);
2082                 AssertValue ((int)Byte.MaxValue + (int)SByte.MaxValue + 1 + 1 + 1 + 1 + 1 + 1 + 'A' + 1 + 3 + 3, v);
2083
2084                 // pass ref
2085                 m = t.GetMethod ("invoke_pass_ref");
2086                 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2087                 AssertValue ("ABC", v);
2088
2089                 // pass null
2090                 m = t.GetMethod ("invoke_pass_ref");
2091                 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.CreateValue (null) });
2092                 AssertValue (null, v);
2093
2094                 // static
2095                 m = t.GetMethod ("invoke_static_pass_ref");
2096                 v = t.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2097                 AssertValue ("ABC", v);
2098
2099                 // static invoked using ObjectMirror.InvokeMethod
2100                 m = t.GetMethod ("invoke_static_pass_ref");
2101                 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2102                 AssertValue ("ABC", v);
2103
2104                 // method which throws an exception
2105                 try {
2106                         m = t.GetMethod ("invoke_throws");
2107                         v = this_obj.InvokeMethod (e.Thread, m, null);
2108                         Assert.Fail ();
2109                 } catch (InvocationException ex) {
2110                         Assert.AreEqual ("Exception", ex.Exception.Type.Name);
2111                 }
2112
2113 #if NET_4_5
2114                 // out argument
2115                 m = t.GetMethod ("invoke_out");
2116                 var out_task = this_obj.InvokeMethodAsyncWithResult (e.Thread, m, new Value [] { vm.CreateValue (1) }, InvokeOptions.ReturnOutArgs);
2117                 var out_args = out_task.Result.OutArgs;
2118                 AssertValue (5, out_args [0]);
2119
2120                 // without ReturnOutArgs flag
2121                 out_task = this_obj.InvokeMethodAsyncWithResult (e.Thread, m, new Value [] { vm.CreateValue (1) });
2122                 out_args = out_task.Result.OutArgs;
2123                 Assert.IsNull (out_args);
2124 #endif
2125
2126                 // newobj
2127                 m = t.GetMethod (".ctor");
2128                 v = t.InvokeMethod (e.Thread, m, null);
2129                 Assert.IsInstanceOfType (typeof (ObjectMirror), v);
2130                 Assert.AreEqual ("Tests", (v as ObjectMirror).Type.Name);
2131
2132                 // interface method
2133                 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("ITest2");
2134                 m = cl1.GetMethod ("invoke_iface");
2135                 v = this_obj.InvokeMethod (e.Thread, m, null);
2136                 AssertValue (42, v);
2137
2138 #if NET_4_5
2139                 // instance
2140                 m = t.GetMethod ("invoke_pass_ref");
2141                 var task = this_obj.InvokeMethodAsync (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2142                 AssertValue ("ABC", task.Result);
2143
2144                 // static
2145                 m = t.GetMethod ("invoke_static_pass_ref");
2146                 task = t.InvokeMethodAsync (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2147                 AssertValue ("ABC", task.Result);
2148 #endif
2149
2150                 // Argument checking
2151
2152                 // null thread
2153                 AssertThrows<ArgumentNullException> (delegate {
2154                                 m = t.GetMethod ("invoke_pass_ref");
2155                                 v = this_obj.InvokeMethod (null, m, new Value [] { vm.CreateValue (null) });
2156                         });
2157
2158                 // null method
2159                 AssertThrows<ArgumentNullException> (delegate {
2160                                 v = this_obj.InvokeMethod (e.Thread, null, new Value [] { vm.CreateValue (null) });
2161                         });
2162
2163                 // invalid number of arguments
2164                 m = t.GetMethod ("invoke_pass_ref");
2165                 AssertThrows<ArgumentException> (delegate {
2166                                 v = this_obj.InvokeMethod (e.Thread, m, null);
2167                         });
2168
2169                 // invalid type of argument (ref != primitive)
2170                 m = t.GetMethod ("invoke_pass_ref");
2171                 AssertThrows<ArgumentException> (delegate {
2172                                 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.CreateValue (1) });
2173                         });
2174
2175                 // invalid type of argument (primitive != primitive)
2176                 m = t.GetMethod ("invoke_pass_primitive_2");
2177                 AssertThrows<ArgumentException> (delegate {
2178                                 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.CreateValue (1) });
2179                         });
2180
2181                 // invoking a non-static method as static
2182                 m = t.GetMethod ("invoke_pass_ref");
2183                 AssertThrows<ArgumentException> (delegate {
2184                                 v = t.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2185                         });
2186
2187                 // invoking a method defined in another class
2188                 m = t2.GetMethod ("invoke");
2189                 AssertThrows<ArgumentException> (delegate {
2190                                 v = this_obj.InvokeMethod (e.Thread, m, null);
2191                         });
2192         }
2193
2194         [Test]
2195         public void InvokeVType () {
2196                 Event e = run_until ("invoke1");
2197
2198                 StackFrame frame = e.Thread.GetFrames () [0];
2199
2200                 var s = frame.GetArgument (1) as StructMirror;
2201
2202                 TypeMirror t = s.Type;
2203
2204                 MethodMirror m;
2205                 Value v;
2206
2207                 // Pass struct as this, receive int
2208                 m = t.GetMethod ("invoke_return_int");
2209                 v = s.InvokeMethod (e.Thread, m, null);
2210                 AssertValue (42, v);
2211
2212                 // Pass struct as this, receive intptr
2213                 m = t.GetMethod ("invoke_return_intptr");
2214                 v = s.InvokeMethod (e.Thread, m, null);
2215                 AssertValue (43, v);
2216
2217                 // Static method
2218                 m = t.GetMethod ("invoke_static");
2219                 v = t.InvokeMethod (e.Thread, m, null);
2220                 AssertValue (5, v);
2221
2222                 // Pass generic struct as this
2223                 s = frame.GetArgument (2) as StructMirror;
2224                 t = s.Type;
2225                 m = t.GetMethod ("invoke_return_int");
2226                 v = s.InvokeMethod (e.Thread, m, null);
2227                 AssertValue (42, v);
2228
2229 #if NET_4_5
2230                 // Invoke a method which changes state
2231                 s = frame.GetArgument (1) as StructMirror;
2232                 t = s.Type;
2233                 m = t.GetMethod ("invoke_mutate");
2234                 var task = s.InvokeMethodAsyncWithResult (e.Thread, m, null, InvokeOptions.ReturnOutThis);
2235                 var out_this = task.Result.OutThis as StructMirror;
2236                 AssertValue (5, out_this ["l"]);
2237
2238                 // Without the ReturnOutThis flag
2239                 s = frame.GetArgument (1) as StructMirror;
2240                 t = s.Type;
2241                 m = t.GetMethod ("invoke_mutate");
2242                 task = s.InvokeMethodAsyncWithResult (e.Thread, m, null);
2243                 out_this = task.Result.OutThis as StructMirror;
2244                 Assert.AreEqual (null, out_this);
2245 #endif
2246         }
2247
2248         [Test]
2249         public void BreakpointDuringInvoke () {
2250                 Event e = run_until ("invoke1");
2251
2252                 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke2");
2253                 Assert.IsNotNull (m);
2254                 vm.SetBreakpoint (m, 0);
2255
2256                 StackFrame frame = e.Thread.GetFrames () [0];
2257                 var o = frame.GetThis () as ObjectMirror;
2258
2259                 bool failed = false;
2260
2261                 bool finished = false;
2262                 object wait = new object ();
2263
2264                 // Have to invoke in a separate thread as the invoke is suspended until we
2265                 // resume after the breakpoint
2266                 Thread t = new Thread (delegate () {
2267                                 try {
2268                                         o.InvokeMethod (e.Thread, m, null);
2269                                 } catch {
2270                                         failed = true;
2271                                 }
2272                                 lock (wait) {
2273                                         finished = true;
2274                                         Monitor.Pulse (wait);
2275                                 }
2276                         });
2277
2278                 t.Start ();
2279
2280                 StackFrame invoke_frame = null;
2281
2282                 try {
2283                         e = GetNextEvent ();
2284                         Assert.IsInstanceOfType (typeof (BreakpointEvent), e);
2285                         // Check stack trace support and invokes
2286                         var frames = e.Thread.GetFrames ();
2287                         invoke_frame = frames [0];
2288                         Assert.AreEqual ("invoke2", frames [0].Method.Name);
2289                         Assert.IsTrue (frames [0].IsDebuggerInvoke);
2290                         Assert.AreEqual ("invoke1", frames [1].Method.Name);
2291                 } finally {
2292                         vm.Resume ();
2293                 }
2294
2295                 lock (wait) {
2296                         if (!finished)
2297                                 Monitor.Wait (wait);
2298                 }
2299
2300                 // Check that the invoke frames are no longer valid
2301                 AssertThrows<InvalidStackFrameException> (delegate {
2302                                 invoke_frame.GetThis ();
2303                         });
2304
2305                 // Check InvokeOptions.DisableBreakpoints flag
2306                 o.InvokeMethod (e.Thread, m, null, InvokeOptions.DisableBreakpoints);
2307         }
2308
2309         [Test]
2310         public void DisabledExceptionDuringInvoke () {
2311                 Event e = run_until ("invoke_ex");
2312
2313                 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke_ex_inner");
2314
2315                 StackFrame frame = e.Thread.GetFrames () [0];
2316                 var o = frame.GetThis () as ObjectMirror;
2317
2318                 var req = vm.CreateExceptionRequest (null);
2319                 req.Enable ();
2320
2321                 // Check InvokeOptions.DisableBreakpoints flag
2322                 o.InvokeMethod (e.Thread, m, null, InvokeOptions.DisableBreakpoints);
2323
2324                 req.Disable ();
2325         }
2326
2327         [Test]
2328         public void InvokeSingleThreaded () {
2329                 vm.Detach ();
2330
2331                 Start (new string [] { "dtest-app.exe", "invoke-single-threaded" });
2332
2333                 Event e = run_until ("invoke_single_threaded_2");
2334
2335                 StackFrame f = e.Thread.GetFrames ()[0];
2336
2337                 var obj = f.GetThis () as ObjectMirror;
2338
2339                 // Check that the counter value incremented by the other thread does not increase
2340                 // during the invoke.
2341                 object counter1 = (obj.GetValue (obj.Type.GetField ("counter")) as PrimitiveValue).Value;
2342
2343                 var m = obj.Type.GetMethod ("invoke_return_void");
2344                 obj.InvokeMethod (e.Thread, m, null, InvokeOptions.SingleThreaded);
2345
2346             object counter2 = (obj.GetValue (obj.Type.GetField ("counter")) as PrimitiveValue).Value;
2347
2348                 Assert.AreEqual ((int)counter1, (int)counter2);
2349
2350                 // Test multiple invokes done in succession
2351                 m = obj.Type.GetMethod ("invoke_return_void");
2352                 obj.InvokeMethod (e.Thread, m, null, InvokeOptions.SingleThreaded);
2353
2354                 // Test events during single-threaded invokes
2355                 vm.EnableEvents (EventType.TypeLoad);
2356                 m = obj.Type.GetMethod ("invoke_type_load");
2357                 obj.BeginInvokeMethod (e.Thread, m, null, InvokeOptions.SingleThreaded, delegate {
2358                                 vm.Resume ();
2359                         }, null);
2360
2361                 e = GetNextEvent ();
2362                 Assert.AreEqual (EventType.TypeLoad, e.EventType);
2363         }
2364
2365         List<Value> invoke_results;
2366
2367         [Test]
2368         public void InvokeMultiple () {
2369                 Event e = run_until ("invoke1");
2370
2371                 StackFrame frame = e.Thread.GetFrames () [0];
2372
2373                 TypeMirror t = frame.Method.DeclaringType;
2374                 ObjectMirror this_obj = (ObjectMirror)frame.GetThis ();
2375
2376                 TypeMirror t2 = frame.Method.GetParameters ()[0].ParameterType;
2377
2378                 var methods = new MethodMirror [2];
2379                 methods [0] = t.GetMethod ("invoke_return_ref");
2380                 methods [1] = t.GetMethod ("invoke_return_primitive");
2381
2382                 invoke_results = new List<Value> ();
2383
2384                 var r = this_obj.BeginInvokeMultiple (e.Thread, methods, null, InvokeOptions.SingleThreaded, invoke_multiple_cb, this_obj);
2385                 WaitHandle.WaitAll (new WaitHandle[] { r.AsyncWaitHandle });
2386                 this_obj.EndInvokeMultiple (r);
2387                 // The callback might still be running
2388                 while (invoke_results.Count < 2) {
2389                         Thread.Sleep (100);
2390                 }
2391                 if (invoke_results [0] is PrimitiveValue) {
2392                         AssertValue ("ABC", invoke_results [1]);
2393                         AssertValue (42, invoke_results [0]);
2394                 } else {
2395                         AssertValue ("ABC", invoke_results [0]);
2396                         AssertValue (42, invoke_results [1]);
2397                 }
2398         }
2399
2400         void invoke_multiple_cb (IAsyncResult ar) {
2401                 ObjectMirror this_obj = (ObjectMirror)ar.AsyncState;
2402
2403                 var res = this_obj.EndInvokeMethod (ar);
2404                 lock (invoke_results)
2405                         invoke_results.Add (res);
2406         }
2407
2408         [Test]
2409         public void GetThreads () {
2410                 vm.GetThreads ();
2411         }
2412
2413         [Test]
2414         public void Threads () {
2415                 Event e = run_until ("threads");
2416
2417                 Assert.AreEqual (ThreadState.Running, e.Thread.ThreadState);
2418
2419                 Assert.IsTrue (e.Thread.ThreadId > 0);
2420
2421                 Assert.AreEqual (e.Thread.TID, e.Thread.TID);
2422
2423                 vm.EnableEvents (EventType.ThreadStart, EventType.ThreadDeath);
2424
2425                 vm.Resume ();
2426
2427                 e = GetNextEvent ();
2428                 Assert.IsInstanceOfType (typeof (ThreadStartEvent), e);
2429                 var state = e.Thread.ThreadState;
2430                 Assert.IsTrue (state == ThreadState.Running || state == ThreadState.Unstarted);
2431
2432                 vm.Resume ();
2433
2434                 e = GetNextEvent ();
2435                 Assert.IsInstanceOfType (typeof (ThreadDeathEvent), e);
2436                 Assert.AreEqual (ThreadState.Stopped, e.Thread.ThreadState);
2437         }
2438
2439         [Test]
2440         public void Frame_SetValue () {
2441                 Event e = run_until ("locals2");
2442
2443                 StackFrame frame = e.Thread.GetFrames () [0];
2444
2445                 // primitive
2446                 var l = frame.Method.GetLocal ("i");
2447                 frame.SetValue (l, vm.CreateValue ((long)55));
2448                 AssertValue (55, frame.GetValue (l));
2449
2450                 // reference
2451                 l = frame.Method.GetLocal ("s");
2452                 frame.SetValue (l, vm.RootDomain.CreateString ("DEF"));
2453                 AssertValue ("DEF", frame.GetValue (l));
2454
2455                 // argument as local
2456                 l = frame.Method.GetLocal ("arg");
2457                 frame.SetValue (l, vm.CreateValue (6));
2458                 AssertValue (6, frame.GetValue (l));
2459
2460                 // argument
2461                 var p = frame.Method.GetParameters ()[1];
2462                 frame.SetValue (p, vm.CreateValue (7));
2463                 AssertValue (7, frame.GetValue (p));
2464
2465                 // gshared
2466                 p = frame.Method.GetParameters ()[2];
2467                 frame.SetValue (p, vm.RootDomain.CreateString ("DEF"));
2468                 AssertValue ("DEF", frame.GetValue (p));
2469
2470                 // byref
2471                 p = frame.Method.GetParameters ()[3];
2472                 frame.SetValue (p, vm.RootDomain.CreateString ("DEF2"));
2473                 AssertValue ("DEF2", frame.GetValue (p));
2474
2475                 // byref struct
2476                 p = frame.Method.GetParameters ()[4];
2477                 var v = frame.GetValue (p) as StructMirror;
2478                 v ["i"] = vm.CreateValue (43);
2479                 frame.SetValue (p, v);
2480                 v = frame.GetValue (p) as StructMirror;
2481                 AssertValue (43, v ["i"]);
2482
2483                 // argument checking
2484
2485                 // variable null
2486                 AssertThrows<ArgumentNullException> (delegate () {
2487                                 frame.SetValue ((LocalVariable)null, vm.CreateValue (55));
2488                         });
2489
2490                 // value null
2491                 AssertThrows<ArgumentNullException> (delegate () {
2492                                 l = frame.Method.GetLocal ("i");
2493                                 frame.SetValue (l, null);
2494                         });
2495
2496                 // value of invalid type
2497                 AssertThrows<ArgumentException> (delegate () {
2498                                 l = frame.Method.GetLocal ("i");
2499                                 frame.SetValue (l, vm.CreateValue (55));
2500                         });
2501         }
2502
2503         [Test]
2504         [Category ("only")]
2505         public void Frame_SetValue_Registers () {
2506                 Event e = run_until ("locals6_1");
2507
2508                 StackFrame frame = e.Thread.GetFrames () [1];
2509
2510                 // Set 'j' to 99
2511                 var l = frame.Method.GetLocal ("j");
2512                 frame.SetValue (l, vm.CreateValue (99));
2513                 AssertValue (99, frame.GetValue (l));
2514
2515                 // Check it during execution
2516                 e = run_until ("locals6_2");
2517                 frame = e.Thread.GetFrames () [0];
2518                 AssertValue (99, frame.GetValue (frame.Method.GetParameters ()[0]));
2519
2520                 // Set it while in a frame which clobbers its register
2521                 e = run_until ("locals6_3");
2522                 frame = e.Thread.GetFrames () [1];
2523                 frame.SetValue (l, vm.CreateValue (100));
2524                 AssertValue (100, frame.GetValue (l));
2525
2526                 // Check it during execution
2527                 e = run_until ("locals6_4");
2528                 frame = e.Thread.GetFrames () [0];
2529                 AssertValue (100, frame.GetValue (frame.Method.GetParameters ()[0]));
2530
2531                 // Signed byte value
2532                 e = run_until ("locals6_5");
2533                 frame = e.Thread.GetFrames () [1];
2534                 var l2 = frame.Method.GetLocal ("sb");
2535                 frame.SetValue (l2, vm.CreateValue ((sbyte)-99));
2536                 AssertValue (-99, frame.GetValue (l2));
2537
2538                 // Check it during execution
2539                 e = run_until ("locals6_6");
2540                 frame = e.Thread.GetFrames () [0];
2541                 AssertValue (-99, frame.GetValue (frame.Method.GetParameters ()[0]));
2542         }
2543
2544         [Test]
2545         public void InvokeRegress () {
2546                 Event e = run_until ("invoke1");
2547
2548                 StackFrame frame = e.Thread.GetFrames () [0];
2549
2550                 TypeMirror t = frame.Method.DeclaringType;
2551                 ObjectMirror this_obj = (ObjectMirror)frame.GetThis ();
2552
2553                 TypeMirror t2 = frame.Method.GetParameters ()[0].ParameterType;
2554
2555                 MethodMirror m;
2556                 Value v;
2557
2558                 // do an invoke
2559                 m = t.GetMethod ("invoke_return_void");
2560                 v = this_obj.InvokeMethod (e.Thread, m, null);
2561                 Assert.IsNull (v);
2562
2563                 // Check that the stack frames remain valid during the invoke
2564                 Assert.AreEqual ("Tests", (frame.GetThis () as ObjectMirror).Type.Name);
2565
2566                 // do another invoke
2567                 m = t.GetMethod ("invoke_return_void");
2568                 v = this_obj.InvokeMethod (e.Thread, m, null);
2569                 Assert.IsNull (v);
2570
2571                 // Try a single step after the invoke
2572                 var req = create_step (e);
2573                 req.Depth = StepDepth.Into;
2574                 req.Size = StepSize.Line;
2575                 req.Enable ();
2576
2577                 // Skip nop
2578                 step_once ();
2579
2580                 // Step into invoke2
2581                 vm.Resume ();
2582                 e = GetNextEvent ();
2583                 Assert.IsTrue (e is StepEvent);
2584                 Assert.AreEqual ("invoke2", (e as StepEvent).Method.Name);
2585
2586                 req.Disable ();
2587
2588                 frame = e.Thread.GetFrames () [0];
2589         }
2590
2591         [Test]
2592         public void Exceptions () {
2593                 Event e = run_until ("exceptions");
2594                 var req = vm.CreateExceptionRequest (null);
2595                 req.Enable ();
2596
2597                 vm.Resume ();
2598
2599                 e = GetNextEvent ();
2600                 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2601                 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2602
2603                 var frames = e.Thread.GetFrames ();
2604                 Assert.AreEqual ("exceptions", frames [0].Method.Name);
2605                 req.Disable ();
2606
2607                 // exception type filter
2608
2609                 req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.ArgumentException"));
2610                 req.Enable ();
2611
2612                 // Skip the throwing of the second OverflowException
2613                 vm.Resume ();
2614
2615                 e = GetNextEvent ();
2616                 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2617                 Assert.AreEqual ("ArgumentException", (e as ExceptionEvent).Exception.Type.Name);
2618                 req.Disable ();
2619
2620                 // exception type filter for subclasses
2621                 req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.Exception"));
2622                 req.Enable ();
2623
2624                 vm.Resume ();
2625
2626                 e = GetNextEvent ();
2627                 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2628                 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2629                 req.Disable ();
2630
2631                 // no subclasses
2632                 req.IncludeSubclasses = false;
2633                 req.Enable ();
2634
2635                 vm.Resume ();
2636
2637                 e = GetNextEvent ();
2638                 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2639                 Assert.AreEqual ("Exception", (e as ExceptionEvent).Exception.Type.Name);
2640                 req.Disable ();
2641
2642                 // Implicit exceptions
2643                 req = vm.CreateExceptionRequest (null);
2644                 req.Enable ();
2645
2646                 vm.Resume ();
2647
2648                 e = GetNextEvent ();
2649                 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2650                 Assert.AreEqual ("NullReferenceException", (e as ExceptionEvent).Exception.Type.Name);
2651                 req.Disable ();
2652
2653                 // Single stepping after an exception
2654                 req = vm.CreateExceptionRequest (null);
2655                 req.Enable ();
2656
2657                 vm.Resume ();
2658
2659                 e = GetNextEvent ();
2660                 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2661                 Assert.AreEqual ("Exception", (e as ExceptionEvent).Exception.Type.Name);
2662                 frames = e.Thread.GetFrames ();
2663                 Assert.AreEqual ("exceptions2", frames [0].Method.Name);
2664                 req.Disable ();
2665
2666                 var sreq = create_step (e);
2667                 sreq.Depth = StepDepth.Over;
2668                 sreq.Size = StepSize.Line;
2669                 sreq.Enable ();
2670
2671                 vm.Resume ();
2672                 e = GetNextEvent ();
2673                 Assert.IsInstanceOfType (typeof (StepEvent), e);
2674                 frames = e.Thread.GetFrames ();
2675                 Assert.AreEqual ("exceptions", frames [0].Method.Name);
2676                 sreq.Disable ();
2677
2678                 // Argument checking
2679                 AssertThrows<ArgumentException> (delegate {
2680                                 vm.CreateExceptionRequest (e.Thread.Type);
2681                         });
2682         }
2683
2684         [Test]
2685         public void ExceptionFilter () {
2686                 Event e = run_until ("exception_filter");
2687
2688                 MethodMirror m = entry_point.DeclaringType.GetMethod ("exception_filter_filter");
2689                 Assert.IsNotNull (m);
2690
2691                 vm.SetBreakpoint (m, 0);
2692
2693                 vm.Resume ();
2694
2695                 e = GetNextEvent ();
2696                 Assert.AreEqual (EventType.Breakpoint, e.EventType);
2697                 Assert.IsTrue (e is BreakpointEvent);
2698                 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
2699
2700                 var frames = e.Thread.GetFrames ();
2701
2702                 Assert.IsTrue (frames [0].Location.SourceFile.IndexOf ("dtest-app.cs") != -1);
2703                 Assert.AreEqual ("exception_filter_filter", frames [0].Location.Method.Name);
2704
2705                 Assert.AreEqual (0, frames [1].Location.Method.MetadataToken);
2706                 Assert.AreEqual (0x0f, frames [1].Location.ILOffset);
2707
2708                 Assert.AreEqual ("exception_filter_method", frames [2].Location.Method.Name);
2709                 Assert.AreEqual (0x06, frames [2].Location.ILOffset);
2710
2711                 Assert.AreEqual (0, frames [3].Location.Method.MetadataToken, 0);
2712                 Assert.AreEqual (0, frames [3].Location.ILOffset);
2713
2714                 Assert.AreEqual ("exception_filter", frames [4].Location.Method.Name);
2715         }
2716
2717         [Test]
2718         public void ExceptionFilter2 () {
2719                 vm.Detach ();
2720
2721                 Start (new string [] { "dtest-excfilter.exe" });
2722
2723                 MethodMirror filter_method = entry_point.DeclaringType.GetMethod ("Filter");
2724                 Assert.IsNotNull (filter_method);
2725
2726                 MethodMirror test_method = entry_point.DeclaringType.GetMethod ("Test");
2727                 Assert.IsNotNull (test_method);
2728
2729                 vm.SetBreakpoint (filter_method, 0);
2730
2731                 vm.Resume ();
2732
2733                 var e = GetNextEvent ();
2734                 Assert.AreEqual (EventType.Breakpoint, e.EventType);
2735                 Assert.IsTrue (e is BreakpointEvent);
2736                 Assert.AreEqual (filter_method.Name, (e as BreakpointEvent).Method.Name);
2737
2738                 var frames = e.Thread.GetFrames ();
2739
2740                 Assert.AreEqual (4, frames.Count ());
2741
2742                 Assert.AreEqual (filter_method.Name, frames [0].Location.Method.Name);
2743                 Assert.AreEqual (20, frames [0].Location.LineNumber);
2744                 Assert.AreEqual (0, frames [0].Location.ILOffset);
2745
2746                 Assert.AreEqual (test_method.Name, frames [1].Location.Method.Name);
2747                 Assert.AreEqual (37, frames [1].Location.LineNumber);
2748                 Assert.AreEqual (0x0b, frames [1].Location.ILOffset);
2749
2750                 Assert.AreEqual (test_method.Name, frames [2].Location.Method.Name);
2751                 Assert.AreEqual (33, frames [2].Location.LineNumber);
2752                 Assert.AreEqual (0x05, frames [2].Location.ILOffset);
2753
2754                 Assert.AreEqual (entry_point.Name, frames [3].Location.Method.Name);
2755                 Assert.AreEqual (14, frames [3].Location.LineNumber);
2756                 Assert.AreEqual (0x00, frames [3].Location.ILOffset);
2757
2758                 vm.Exit (0);
2759
2760                 vm = null;
2761         }
2762
2763         [Test]
2764         public void EventSets () {
2765                 //
2766                 // Create two filter which both match the same exception
2767                 //
2768                 Event e = run_until ("exceptions");
2769
2770                 var req = vm.CreateExceptionRequest (null);
2771                 req.Enable ();
2772
2773                 var req2 = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.OverflowException"));
2774                 req2.Enable ();
2775
2776                 vm.Resume ();
2777
2778                 var es = vm.GetNextEventSet ();
2779                 Assert.AreEqual (2, es.Events.Length);
2780
2781                 e = es [0];
2782                 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2783                 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2784
2785                 e = es [1];
2786                 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2787                 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2788
2789                 req.Disable ();
2790                 req2.Disable ();
2791         }
2792
2793         //
2794         // Test single threaded invokes during processing of nullref exceptions.
2795         // These won't work if the exception handling is done from the sigsegv signal
2796         // handler, since the sigsegv signal is disabled until control returns from the
2797         // signal handler.
2798         //
2799         [Test]
2800         [Category ("only3")]
2801         public void NullRefExceptionAndSingleThreadedInvoke () {
2802                 Event e = run_until ("exceptions");
2803                 var req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.NullReferenceException"));
2804                 req.Enable ();
2805
2806                 vm.Resume ();
2807
2808                 e = GetNextEvent ();
2809                 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2810                 Assert.AreEqual ("NullReferenceException", (e as ExceptionEvent).Exception.Type.Name);
2811
2812                 var ex = (e as ExceptionEvent).Exception;
2813                 var tostring_method = vm.RootDomain.Corlib.GetType ("System.Object").GetMethod ("ToString");
2814                 ex.InvokeMethod (e.Thread, tostring_method, null, InvokeOptions.SingleThreaded);
2815         }
2816
2817         [Test]
2818         public void Domains () {
2819                 vm.Detach ();
2820
2821                 Start (new string [] { "dtest-app.exe", "domain-test" });
2822
2823                 vm.EnableEvents (EventType.AppDomainCreate, EventType.AppDomainUnload, EventType.AssemblyUnload);
2824
2825                 Event e = run_until ("domains");
2826
2827                 vm.Resume ();
2828
2829                 e = GetNextEvent ();
2830                 Assert.IsInstanceOfType (typeof (AppDomainCreateEvent), e);
2831
2832                 var domain = (e as AppDomainCreateEvent).Domain;
2833
2834                 // Check the object type
2835                 e = run_until ("domains_2");
2836                 var frame = e.Thread.GetFrames ()[0];
2837                 var o = frame.GetArgument (0) as ObjectMirror;
2838                 Assert.AreEqual ("CrossDomain", o.Type.Name);
2839
2840                 // Do a remoting invoke
2841                 var cross_domain_type = o.Type;
2842                 var v = o.InvokeMethod (e.Thread, cross_domain_type.GetMethod ("invoke_3"), null);
2843                 AssertValue (42, v);
2844
2845                 // Run until the callback in the domain
2846                 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke_in_domain");
2847                 Assert.IsNotNull (m);
2848                 vm.SetBreakpoint (m, 0);
2849
2850                 while (true) {
2851                         vm.Resume ();
2852                         e = GetNextEvent ();
2853                         if (e is BreakpointEvent)
2854                                 break;
2855                 }
2856
2857                 Assert.AreEqual ("invoke_in_domain", (e as BreakpointEvent).Method.Name);
2858
2859                 // d_method is from another domain
2860                 MethodMirror d_method = (e as BreakpointEvent).Method;
2861                 Assert.IsTrue (m != d_method);
2862
2863                 var frames = e.Thread.GetFrames ();
2864                 Assert.AreEqual ("invoke_in_domain", frames [0].Method.Name);
2865                 Assert.AreEqual ("invoke", frames [1].Method.Name);
2866                 Assert.AreEqual ("domains", frames [2].Method.Name);
2867
2868                 // Test breakpoints on already JITted methods in other domains
2869                 m = entry_point.DeclaringType.GetMethod ("invoke_in_domain_2");
2870                 Assert.IsNotNull (m);
2871                 vm.SetBreakpoint (m, 0);
2872
2873                 while (true) {
2874                         vm.Resume ();
2875                         e = GetNextEvent ();
2876                         if (e is BreakpointEvent)
2877                                 break;
2878                 }
2879
2880                 Assert.AreEqual ("invoke_in_domain_2", (e as BreakpointEvent).Method.Name);
2881
2882                 // This is empty when receiving the AppDomainCreateEvent
2883                 Assert.AreEqual ("domain", domain.FriendlyName);
2884
2885                 // Run until the unload
2886                 while (true) {
2887                         vm.Resume ();
2888                         e = GetNextEvent ();
2889                         if (e is AssemblyUnloadEvent) {
2890                                 continue;
2891                         } else {
2892                                 break;
2893                         }
2894                 }
2895                 Assert.IsInstanceOfType (typeof (AppDomainUnloadEvent), e);
2896                 Assert.AreEqual (domain, (e as AppDomainUnloadEvent).Domain);
2897
2898                 // Run past the unload
2899                 e = run_until ("domains_3");
2900
2901                 // Test access to unloaded types
2902                 // FIXME: Add an exception type for this
2903                 AssertThrows<Exception> (delegate {
2904                                 d_method.DeclaringType.GetValue (d_method.DeclaringType.GetField ("static_i"));
2905                         });
2906         }
2907
2908         [Test]
2909         public void DynamicMethods () {
2910                 Event e = run_until ("dyn_call");
2911
2912                 var m = e.Thread.GetFrames ()[1].Method;
2913                 Assert.AreEqual ("dyn_method", m.Name);
2914
2915                 // Test access to IL
2916                 var body = m.GetMethodBody ();
2917
2918                 ILInstruction ins = body.Instructions [0];
2919                 Assert.AreEqual (OpCodes.Ldstr, ins.OpCode);
2920                 Assert.AreEqual ("FOO", ins.Operand);
2921         }
2922
2923         [Test]
2924         public void RefEmit () {
2925                 vm.Detach ();
2926
2927                 Start (new string [] { "dtest-app.exe", "ref-emit-test" });
2928
2929                 Event e = run_until ("ref_emit_call");
2930
2931                 var m = e.Thread.GetFrames ()[1].Method;
2932                 Assert.AreEqual ("ref_emit_method", m.Name);
2933
2934                 // Test access to IL
2935                 var body = m.GetMethodBody ();
2936
2937                 ILInstruction ins;
2938
2939                 ins = body.Instructions [0];
2940                 Assert.AreEqual (OpCodes.Ldstr, ins.OpCode);
2941                 Assert.AreEqual ("FOO", ins.Operand);
2942
2943                 ins = body.Instructions [1];
2944                 Assert.AreEqual (OpCodes.Call, ins.OpCode);
2945                 Assert.IsInstanceOfType (typeof (MethodMirror), ins.Operand);
2946                 Assert.AreEqual ("ref_emit_call", (ins.Operand as MethodMirror).Name);
2947         }
2948
2949         [Test]
2950         public void IsAttached () {
2951                 var f = entry_point.DeclaringType.GetField ("is_attached");
2952
2953                 Event e = run_until ("Main");
2954
2955                 AssertValue (true, entry_point.DeclaringType.GetValue (f));
2956         }
2957
2958         [Test]
2959         public void StackTraceInNative () {
2960                 // Check that stack traces can be produced for threads in native code
2961                 vm.Detach ();
2962
2963                 Start (new string [] { "dtest-app.exe", "frames-in-native" });
2964
2965                 var e = run_until ("frames_in_native");
2966
2967                 // FIXME: This is racy
2968                 vm.Resume ();
2969
2970                 Thread.Sleep (100);
2971
2972                 vm.Suspend ();
2973
2974                 StackFrame[] frames = e.Thread.GetFrames ();
2975
2976                 int frame_index = -1;
2977                 for (int i = 0; i < frames.Length; ++i) {
2978                         if (frames [i].Method.Name == "Sleep") {
2979                                 frame_index = i;
2980                                 break;
2981                         }
2982                 }
2983
2984                 Assert.IsTrue (frame_index != -1);
2985                 Assert.AreEqual ("Sleep", frames [frame_index].Method.Name);
2986                 Assert.AreEqual ("frames_in_native", frames [frame_index + 1].Method.Name);
2987                 Assert.AreEqual ("Main", frames [frame_index + 2].Method.Name);
2988
2989                 // Check that invokes are disabled for such threads
2990                 TypeMirror t = frames [frame_index + 1].Method.DeclaringType;
2991
2992                 var m = t.GetMethod ("invoke_static_return_void");
2993                 AssertThrows<InvalidOperationException> (delegate {
2994                                 t.InvokeMethod (e.Thread, m, null);
2995                         });
2996
2997                 // Check that the frame info is invalidated
2998                 run_until ("frames_in_native_2");
2999
3000                 AssertThrows<InvalidStackFrameException> (delegate {
3001                                 Console.WriteLine (frames [frame_index].GetThis ());
3002                         });
3003         }
3004
3005         [Test]
3006         public void VirtualMachine_CreateEnumMirror () {
3007                 var e = run_until ("o1");
3008                 var frame = e.Thread.GetFrames () [0];
3009
3010                 object val = frame.GetThis ();
3011                 Assert.IsTrue (val is ObjectMirror);
3012                 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
3013                 ObjectMirror o = (val as ObjectMirror);
3014
3015                 FieldInfoMirror field = o.Type.GetField ("field_enum");
3016                 Value f = o.GetValue (field);
3017                 TypeMirror enumType = (f as EnumMirror).Type;
3018
3019                 o.SetValue (field, vm.CreateEnumMirror (enumType, vm.CreateValue (1)));
3020                 f = o.GetValue (field);
3021                 Assert.AreEqual (1, (f as EnumMirror).Value);
3022
3023                 // Argument checking
3024                 AssertThrows<ArgumentNullException> (delegate () {
3025                                 vm.CreateEnumMirror (enumType, null);
3026                         });
3027
3028                 AssertThrows<ArgumentNullException> (delegate () {
3029                                 vm.CreateEnumMirror (null, vm.CreateValue (1));
3030                         });
3031
3032                 // null value
3033                 AssertThrows<ArgumentException> (delegate () {
3034                                 vm.CreateEnumMirror (enumType, vm.CreateValue (null));
3035                         });
3036
3037                 // value of a wrong type
3038                 AssertThrows<ArgumentException> (delegate () {
3039                                 vm.CreateEnumMirror (enumType, vm.CreateValue ((long)1));
3040                         });
3041         }
3042
3043         [Test]
3044         public void VirtualMachine_EnableEvents_Breakpoint () {
3045                 AssertThrows<ArgumentException> (delegate () {
3046                                 vm.EnableEvents (EventType.Breakpoint);
3047                         });
3048         }
3049
3050         [Test]
3051         public void SingleStepRegress654694 () {
3052                 int il_offset = -1;
3053
3054                 MethodMirror m = entry_point.DeclaringType.GetMethod ("ss_regress_654694");
3055                 foreach (Location l in m.Locations) {
3056                         if (l.ILOffset > 0 && il_offset == -1)
3057                                 il_offset = l.ILOffset;
3058                 }
3059
3060                 Event e = run_until ("ss_regress_654694");
3061
3062                 Assert.IsNotNull (m);
3063                 vm.SetBreakpoint (m, il_offset);
3064
3065                 vm.Resume ();
3066
3067                 e = GetNextEvent ();
3068                 Assert.IsTrue (e is BreakpointEvent);
3069
3070                 var req = create_step (e);
3071                 req.Depth = StepDepth.Over;
3072                 req.Size = StepSize.Line;
3073                 req.Enable ();
3074
3075                 vm.Resume ();
3076
3077                 e = GetNextEvent ();
3078                 Assert.IsTrue (e is StepEvent);
3079
3080                 req.Disable ();
3081         }
3082
3083         [Test]
3084         public void DebugBreak () {
3085                 vm.EnableEvents (EventType.UserBreak);
3086
3087                 run_until ("user");
3088
3089                 vm.Resume ();
3090                 var e = GetNextEvent ();
3091                 Assert.IsTrue (e is UserBreakEvent);
3092         }
3093
3094         [Test]
3095         public void DebugLog () {
3096                 vm.EnableEvents (EventType.UserLog);
3097
3098                 run_until ("user");
3099
3100                 vm.Resume ();
3101                 var e = GetNextEvent ();
3102                 Assert.IsTrue (e is UserLogEvent);
3103                 var le = e as UserLogEvent;
3104
3105                 Assert.AreEqual (5, le.Level);
3106                 Assert.AreEqual ("A", le.Category);
3107                 Assert.AreEqual ("B", le.Message);
3108         }
3109
3110         [Test]
3111         public void TypeGetMethodsByNameFlags () {
3112                 MethodMirror[] mm;
3113                 var assembly = entry_point.DeclaringType.Assembly;
3114                 var type = assembly.GetType ("Tests3");
3115
3116                 Assert.IsNotNull (type);
3117
3118                 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.Public, false);
3119                 Assert.AreEqual (1, mm.Length, "#1");
3120                 Assert.AreEqual ("M1", mm[0].Name, "#2");
3121
3122                 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.NonPublic, false);
3123                 Assert.AreEqual (1, mm.Length, "#3");
3124                 Assert.AreEqual ("M2", mm[0].Name, "#4");
3125
3126                 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.Public, false);
3127                 Assert.AreEqual (7, mm.Length, "#5"); //M3 plus Equals, GetHashCode, GetType, ToString, .ctor
3128
3129                 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly, false);
3130                 Assert.AreEqual (2, mm.Length, "#7");
3131
3132                 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly, false);
3133                 Assert.AreEqual (1, mm.Length, "#9");
3134
3135                 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly, false);
3136                 Assert.AreEqual (5, mm.Length, "#11");
3137
3138                 //Now with name
3139                 mm = type.GetMethodsByNameFlags ("M1", BindingFlags.Static | BindingFlags.Public, false);
3140                 Assert.AreEqual (1, mm.Length, "#12");
3141                 Assert.AreEqual ("M1", mm[0].Name, "#13");
3142
3143                 mm = type.GetMethodsByNameFlags ("m1", BindingFlags.Static | BindingFlags.Public, true);
3144                 Assert.AreEqual (1, mm.Length, "#14");
3145                 Assert.AreEqual ("M1", mm[0].Name, "#15");
3146
3147                 mm = type.GetMethodsByNameFlags ("M1", BindingFlags.Static  | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, false);
3148                 Assert.AreEqual (1, mm.Length, "#16");
3149                 Assert.AreEqual ("M1", mm[0].Name, "#17");
3150         }
3151
3152         [Test]
3153         [Category ("only88")]
3154         public void TypeLoadSourceFileFilter () {
3155                 Event e = run_until ("type_load");
3156
3157                 if (!vm.Version.AtLeast (2, 7))
3158                         return;
3159
3160                 string srcfile = (e as BreakpointEvent).Method.DeclaringType.GetSourceFiles (true)[0];
3161
3162                 var req = vm.CreateTypeLoadRequest ();
3163                 req.SourceFileFilter = new string [] { srcfile.ToUpper () };
3164                 req.Enable ();
3165
3166                 vm.Resume ();
3167                 e = GetNextEvent ();
3168                 Assert.IsTrue (e is TypeLoadEvent);
3169                 Assert.AreEqual ("TypeLoadClass", (e as TypeLoadEvent).Type.FullName);
3170         }
3171
3172         [Test]
3173         public void TypeLoadTypeNameFilter () {
3174                 Event e = run_until ("type_load");
3175
3176                 var req = vm.CreateTypeLoadRequest ();
3177                 req.TypeNameFilter = new string [] { "TypeLoadClass2" };
3178                 req.Enable ();
3179
3180                 vm.Resume ();
3181                 e = GetNextEvent ();
3182                 Assert.IsTrue (e is TypeLoadEvent);
3183                 Assert.AreEqual ("TypeLoadClass2", (e as TypeLoadEvent).Type.FullName);
3184         }
3185
3186         [Test]
3187         public void GetTypesForSourceFile () {
3188                 run_until ("user");
3189
3190                 var types = vm.GetTypesForSourceFile ("dtest-app.cs", false);
3191                 Assert.IsTrue (types.Any (t => t.FullName == "Tests"));
3192                 Assert.IsFalse (types.Any (t => t.FullName == "System.Int32"));
3193
3194                 types = vm.GetTypesForSourceFile ("DTEST-app.cs", true);
3195                 Assert.IsTrue (types.Any (t => t.FullName == "Tests"));
3196                 Assert.IsFalse (types.Any (t => t.FullName == "System.Int32"));
3197         }
3198
3199         [Test]
3200         public void GetTypesNamed () {
3201                 run_until ("user");
3202
3203                 var types = vm.GetTypes ("Tests", false);
3204                 Assert.AreEqual (1, types.Count);
3205                 Assert.AreEqual ("Tests", types [0].FullName);
3206
3207                 types = vm.GetTypes ("System.Exception", false);
3208                 Assert.AreEqual (1, types.Count);
3209                 Assert.AreEqual ("System.Exception", types [0].FullName);
3210         }
3211
3212         [Test]
3213         public void String_GetChars () {
3214                 object val;
3215
3216                 // Reuse this test
3217                 var e = run_until ("arg2");
3218
3219                 var frame = e.Thread.GetFrames () [0];
3220
3221                 val = frame.GetArgument (0);
3222                 Assert.IsTrue (val is StringMirror);
3223                 AssertValue ("FOO", val);
3224                 var s = (val as StringMirror);
3225                 Assert.AreEqual (3, s.Length);
3226
3227                 var c = s.GetChars (0, 2);
3228                 Assert.AreEqual (2, c.Length);
3229                 Assert.AreEqual ('F', c [0]);
3230                 Assert.AreEqual ('O', c [1]);
3231
3232                 AssertThrows<ArgumentException> (delegate () {
3233                                 s.GetChars (2, 2);
3234                         });
3235         }
3236
3237         [Test]
3238         public void GetInterfaces () {
3239                 var e = run_until ("arg2");
3240
3241                 var frame = e.Thread.GetFrames () [0];
3242
3243                 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("TestIfaces");
3244                 var ifaces = cl1.GetInterfaces ();
3245                 Assert.AreEqual (1, ifaces.Length);
3246                 Assert.AreEqual ("ITest", ifaces [0].Name);
3247
3248                 var cl2 = cl1.GetMethod ("Baz").ReturnType;
3249                 var ifaces2 = cl2.GetInterfaces ();
3250                 Assert.AreEqual (1, ifaces2.Length);
3251                 Assert.AreEqual ("ITest`1", ifaces2 [0].Name);
3252         }
3253
3254         [Test]
3255         public void GetInterfaceMap () {
3256                 var e = run_until ("arg2");
3257
3258                 var frame = e.Thread.GetFrames () [0];
3259
3260                 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("TestIfaces");
3261                 var iface = cl1.Assembly.GetType ("ITest");
3262                 var map = cl1.GetInterfaceMap (iface);
3263                 Assert.AreEqual (cl1, map.TargetType);
3264                 Assert.AreEqual (iface, map.InterfaceType);
3265                 Assert.AreEqual (2, map.InterfaceMethods.Length);
3266                 Assert.AreEqual (2, map.TargetMethods.Length);
3267         }
3268
3269         [Test]
3270         public void StackAlloc_Breakpoints_Regress2775 () {
3271                 // Check that breakpoints on arm don't overwrite stackalloc-ed memory
3272                 var e = run_until ("regress_2755");
3273
3274                 var frame = e.Thread.GetFrames () [0];
3275                 var m = e.Method;
3276                 // This breaks at the call site
3277                 vm.SetBreakpoint (m, m.Locations [2].ILOffset);
3278
3279                 vm.Resume ();
3280                 var e2 = GetNextEvent ();
3281                 Assert.IsTrue (e2 is BreakpointEvent);
3282
3283                 e = run_until ("regress_2755_3");
3284                 frame = e.Thread.GetFrames () [1];
3285                 var res = frame.GetValue (m.GetLocal ("sum"));
3286                 AssertValue (0, res);
3287         }
3288
3289         [Test]
3290         public void MethodInfo () {
3291                 Event e = run_until ("locals2");
3292
3293                 StackFrame frame = e.Thread.GetFrames () [0];
3294                 var m = frame.Method;
3295
3296                 Assert.IsTrue (m.IsGenericMethod);
3297                 Assert.IsFalse (m.IsGenericMethodDefinition);
3298
3299                 var args = m.GetGenericArguments ();
3300                 Assert.AreEqual (1, args.Length);
3301                 Assert.AreEqual ("String", args [0].Name);
3302
3303                 var gmd = m.GetGenericMethodDefinition ();
3304                 Assert.IsTrue (gmd.IsGenericMethod);
3305                 Assert.IsTrue (gmd.IsGenericMethodDefinition);
3306                 Assert.AreEqual (gmd, gmd.GetGenericMethodDefinition ());
3307
3308                 args = gmd.GetGenericArguments ();
3309                 Assert.AreEqual (1, args.Length);
3310                 Assert.AreEqual ("T", args [0].Name);
3311
3312                 var attrs = m.GetCustomAttributes (true);
3313                 Assert.AreEqual (1, attrs.Length);
3314                 Assert.AreEqual ("StateMachineAttribute", attrs [0].Constructor.DeclaringType.Name);
3315         }
3316
3317         [Test]
3318         public void UnhandledException () {
3319                 vm.Exit (0);
3320
3321                 Start (new string [] { "dtest-app.exe", "unhandled-exception" });
3322
3323                 var req = vm.CreateExceptionRequest (null, false, true);
3324                 req.Enable ();
3325
3326                 var e = run_until ("unhandled_exception");
3327                 vm.Resume ();
3328
3329                 var e2 = GetNextEvent ();
3330                 Assert.IsTrue (e2 is ExceptionEvent);
3331
3332                 vm.Exit (0);
3333                 vm = null;
3334         }
3335
3336         [Test]
3337         public void UnhandledException_2 () {
3338                 vm.Exit (0);
3339
3340                 Start (new string [] { "dtest-app.exe", "unhandled-exception-endinvoke" });
3341
3342                 var req = vm.CreateExceptionRequest (null, false, true);
3343                 req.Enable ();
3344
3345                 MethodMirror m = entry_point.DeclaringType.GetMethod ("unhandled_exception_endinvoke_2");
3346                 Assert.IsNotNull (m);
3347                 vm.SetBreakpoint (m, m.ILOffsets [0]);
3348
3349                 var e = run_until ("unhandled_exception_endinvoke");
3350                 vm.Resume ();
3351
3352                 var e2 = GetNextEvent ();
3353                 Assert.IsFalse (e2 is ExceptionEvent);
3354
3355                 vm.Exit (0);
3356                 vm = null;
3357         }
3358
3359 #if NET_4_5
3360         [Test]
3361         public void UnhandledExceptionUserCode () {
3362                 vm.Detach ();
3363
3364                 // Exceptions caught in non-user code are treated as unhandled
3365                 Start (new string [] { "dtest-app.exe", "unhandled-exception-user" });
3366
3367                 var req = vm.CreateExceptionRequest (null, false, true);
3368                 req.AssemblyFilter = new List<AssemblyMirror> () { entry_point.DeclaringType.Assembly };
3369                 req.Enable ();
3370
3371                 var e = run_until ("unhandled_exception_user");
3372                 vm.Resume ();
3373
3374                 var e2 = GetNextEvent ();
3375                 Assert.IsTrue (e2 is ExceptionEvent);
3376
3377                 vm.Exit (0);
3378                 vm = null;
3379         }
3380 #endif
3381
3382         [Test]
3383         public void GCWhileSuspended () {
3384                 // Check that objects are kept alive during suspensions
3385                 Event e = run_until ("gc_suspend_1");
3386
3387                 MethodMirror m = entry_point.DeclaringType.GetMethod ("gc_suspend_invoke");
3388
3389                 var o = entry_point.DeclaringType.GetValue (entry_point.DeclaringType.GetField ("gc_suspend_field")) as ObjectMirror;
3390                 //Console.WriteLine (o);
3391
3392                 StackFrame frame = e.Thread.GetFrames () [0];
3393                 TypeMirror t = frame.Method.DeclaringType;
3394                 for (int i = 0; i < 10; ++i)
3395                         t.InvokeMethod (e.Thread, m, new Value [] { });
3396
3397                 // This throws an exception if the object is collected
3398                 long addr = o.Address;
3399
3400                 var o2 = entry_point.DeclaringType.GetValue (entry_point.DeclaringType.GetField ("gc_suspend_field")) as ObjectMirror;
3401                 Assert.IsNull (o2);
3402         }
3403
3404         [Test]
3405         public void MakeGenericMethod () {
3406                 Event e = run_until ("bp1");
3407
3408                 var intm = vm.RootDomain.GetCorrespondingType (typeof (int));
3409                 var stringm = vm.RootDomain.GetCorrespondingType (typeof (string));
3410                 var gm = entry_point.DeclaringType.GetMethod ("generic_method");
3411                 var res = gm.MakeGenericMethod (new TypeMirror [] { stringm });
3412                 var args = res.GetGenericArguments ();
3413                 Assert.AreEqual (1, args.Length);
3414                 Assert.AreEqual (stringm, args [0]);
3415
3416                 // Error checking
3417                 AssertThrows<ArgumentNullException> (delegate {
3418                                 gm.MakeGenericMethod (null);
3419                         });
3420                 AssertThrows<ArgumentNullException> (delegate {
3421                                 gm.MakeGenericMethod (new TypeMirror [] { null });
3422                         });
3423                 AssertThrows<ArgumentException> (delegate {
3424                                 gm.MakeGenericMethod (new TypeMirror [] { stringm, stringm });
3425                         });
3426                 AssertThrows<InvalidOperationException> (delegate {
3427                                 gm.MakeGenericMethod (new TypeMirror [] { intm });
3428                         });
3429                 AssertThrows<InvalidOperationException> (delegate {
3430                                 entry_point.DeclaringType.GetMethod ("Main").MakeGenericMethod (new TypeMirror [] { intm });
3431                         });
3432         }
3433
3434         [Test]
3435         public void InspectThreadSuspenedOnWaitOne () {
3436                 TearDown ();
3437                 Start (true, "dtest-app.exe", "wait-one" );
3438
3439                 ThreadMirror.NativeTransitions = true;
3440
3441                 var evt = run_until ("wait_one");
3442                 Assert.IsNotNull (evt, "#1");
3443
3444                 var thread = evt.Thread;
3445                 Assert.AreEqual (ThreadState.Running, thread.ThreadState, "#1.1");
3446
3447                 var frames = thread.GetFrames ();
3448                 Assert.IsNotNull (frames, "#2");
3449                 Assert.AreEqual (2, frames.Length, "#3");
3450                 Assert.AreEqual ("wait_one", frames [0].Method.Name, "#4");
3451                 Assert.AreEqual ("Main", frames [1].Method.Name, "#5");
3452
3453                 vm.Resume ();
3454
3455                 Thread.Sleep (500); //FIXME this is racy, maybe single step? or something?
3456
3457                 vm.Suspend ();
3458                 Assert.AreEqual (ThreadState.WaitSleepJoin, thread.ThreadState, "#6");
3459
3460                 frames = thread.GetFrames ();
3461                 Assert.AreEqual (4, frames.Length, "#7");
3462                 Assert.AreEqual ("WaitOne_internal", frames [0].Method.Name, "#8");
3463                 Assert.AreEqual ("WaitOne", frames [1].Method.Name, "#8.1");
3464                 Assert.AreEqual ("wait_one", frames [2].Method.Name, "#9");
3465                 Assert.AreEqual ("Main", frames [3].Method.Name, "#10");
3466
3467
3468                 var frame = frames [0];
3469                 Assert.IsTrue (frame.IsNativeTransition, "#11.1");
3470                 try {
3471                         frame.GetThis ();
3472                         Assert.Fail ("Known limitation - can't get info from m2n frames");
3473                 } catch (AbsentInformationException) {}
3474
3475                 frame = frames [1];
3476                 Assert.IsFalse (frame.IsNativeTransition, "#12.1");
3477                 var wait_one_this = frame.GetThis ();
3478                 Assert.IsNotNull (wait_one_this, "#12.2");
3479
3480                 frame = frames [2];
3481                 var locals = frame.GetVisibleVariables ();
3482                 Assert.AreEqual (1, locals.Count, "#13.1");
3483
3484                 var local_0 = frame.GetValue (locals [0]);
3485                 Assert.IsNotNull (local_0, "#13.2");
3486
3487                 Assert.AreEqual (wait_one_this, local_0, "#14.2");
3488         }
3489
3490         [Test]
3491         public void GetMethodBody () {
3492                 var bevent = run_until ("Main");
3493
3494                 var m = bevent.Method.DeclaringType.GetMethod ("get_IntProperty");
3495                 var body = m.GetMethodBody ();
3496                 foreach (var ins in body.Instructions) {
3497                         if (ins.OpCode == OpCodes.Ldfld) {
3498                                 var field = (FieldInfoMirror)ins.Operand;
3499                                 Assert.AreEqual ("field_i", field.Name);
3500                         }
3501                 }
3502         }
3503
3504         [Test]
3505         public void EvaluateMethod () {
3506                 var bevent = run_until ("evaluate_method_2");
3507
3508                 var m = bevent.Method.DeclaringType.GetMethod ("get_IntProperty");
3509
3510                 var this_obj = bevent.Thread.GetFrames ()[0].GetThis ();
3511                 var v = m.Evaluate (this_obj, null);
3512                 AssertValue (42, v);
3513         }
3514
3515         [Test]
3516         public void SetIP () {
3517                 var bevent = run_until ("set_ip_1");
3518
3519                 var invalid_loc = bevent.Thread.GetFrames ()[0].Location;
3520
3521                 var req = create_step (bevent);
3522                 var e = step_out ();
3523                 req.Disable ();
3524                 var frames = e.Thread.GetFrames ();
3525                 var locs = frames [0].Method.Locations;
3526                 var next_loc = locs.First (l => (l.LineNumber == frames [0].Location.LineNumber + 2));
3527
3528                 e.Thread.SetIP (next_loc);
3529
3530                 /* Check that i = 5; j = 5; was skipped */
3531                 bevent = run_until ("set_ip_2");
3532                 var f = bevent.Thread.GetFrames ()[1];
3533                 AssertValue (1, f.GetValue (f.Method.GetLocal ("i")));
3534                 AssertValue (0, f.GetValue (f.Method.GetLocal ("j")));
3535
3536                 // Error handling
3537                 AssertThrows<ArgumentNullException> (delegate {
3538                                 e.Thread.SetIP (null);
3539                         });
3540
3541                 AssertThrows<ArgumentException> (delegate {
3542                                 e.Thread.SetIP (invalid_loc);
3543                         });
3544         }
3545
3546         [Test]
3547         public void NewInstanceNoCtor () {
3548                 var bevent = run_until ("Main");
3549
3550                 var stype = bevent.Method.DeclaringType.Assembly.GetType ("AStruct");
3551                 var obj = stype.NewInstance ();
3552                 Assert.IsTrue (obj is ObjectMirror);
3553                 Assert.AreEqual ("AStruct", (obj as ObjectMirror).Type.Name);
3554         }
3555 }
3556
3557 }