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