2 using System.Collections.Generic;
3 using System.Threading;
7 using Diag = System.Diagnostics;
11 #pragma warning disable 0219
14 public class DebuggerTests
17 MethodMirror entry_point;
18 StepEventRequest step_req;
20 void AssertThrows<ExType> (Action del) where ExType : Exception {
28 Assert.IsTrue (thrown);
31 // No other way to pass arguments to the tests ?
32 public static bool listening = Environment.GetEnvironmentVariable ("DBG_SUSPEND") != null;
33 public static string runtime = Environment.GetEnvironmentVariable ("DBG_RUNTIME");
35 void Start (string[] args) {
37 var pi = new Diag.ProcessStartInfo ();
40 pi.FileName = runtime;
43 pi.Arguments = String.Join (" ", args);
44 vm = VirtualMachineManager.Launch (pi, new LaunchOptions { AgentArgs = "loglevel=0" });
46 Console.WriteLine ("Listening...");
47 vm = VirtualMachineManager.Listen (new IPEndPoint (IPAddress.Any, 10000));
50 vm.EnableEvents (EventType.AssemblyLoad);
52 Event vmstart = vm.GetNextEvent ();
53 Assert.AreEqual (EventType.VMStart, vmstart.EventType);
62 /* Find out the entry point */
64 e = vm.GetNextEvent ();
66 if (e is AssemblyLoadEvent) {
67 AssemblyLoadEvent ae = (AssemblyLoadEvent)e;
68 entry_point = ae.Assembly.EntryPoint;
69 if (entry_point != null)
78 public void SetUp () {
79 Start (new string [] { "dtest-app.exe" });
83 public void TearDown () {
92 Event e = vm.GetNextEvent ();
94 if (e is VMDeathEvent)
102 public void SimpleBreakpoint () {
105 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp1");
106 Assert.IsNotNull (m);
108 vm.SetBreakpoint (m, 0);
112 e = vm.GetNextEvent ();
113 Assert.AreEqual (EventType.Breakpoint, e.EventType);
114 Assert.IsTrue (e is BreakpointEvent);
115 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
118 AssertThrows<ArgumentException> (delegate {
120 vm.SetBreakpoint (m, 1);
125 public void BreakpointsSameLocation () {
128 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp2");
129 Assert.IsNotNull (m);
131 vm.SetBreakpoint (m, 0);
132 vm.SetBreakpoint (m, 0);
136 e = vm.GetNextEvent ();
137 Assert.IsTrue (e is BreakpointEvent);
138 Assert.AreEqual (m, (e as BreakpointEvent).Method);
140 e = vm.GetNextEvent ();
141 Assert.IsTrue (e is BreakpointEvent);
142 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
146 public void BreakpointAlreadyJITted () {
147 Event e = run_until ("bp1");
149 /* Place a breakpoint on bp3 */
150 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp3");
151 Assert.IsNotNull (m);
152 vm.SetBreakpoint (m, 0);
154 /* Same with generic instances */
155 MethodMirror m2 = entry_point.DeclaringType.GetMethod ("bp7");
156 Assert.IsNotNull (m2);
157 vm.SetBreakpoint (m2, 0);
161 e = vm.GetNextEvent ();
162 Assert.AreEqual (EventType.Breakpoint, e.EventType);
163 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
167 /* Non-shared instance */
168 e = vm.GetNextEvent ();
169 Assert.AreEqual (EventType.Breakpoint, e.EventType);
170 Assert.AreEqual (m2.Name, (e as BreakpointEvent).Method.Name);
174 /* Shared instance */
175 e = vm.GetNextEvent ();
176 Assert.AreEqual (EventType.Breakpoint, e.EventType);
177 Assert.AreEqual (m2.Name, (e as BreakpointEvent).Method.Name);
181 public void ClearBreakpoint () {
184 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp4");
185 Assert.IsNotNull (m);
186 EventRequest req1 = vm.SetBreakpoint (m, 0);
187 EventRequest req2 = vm.SetBreakpoint (m, 0);
189 MethodMirror m2 = entry_point.DeclaringType.GetMethod ("bp5");
190 Assert.IsNotNull (m2);
191 vm.SetBreakpoint (m2, 0);
196 e = vm.GetNextEvent ();
197 Assert.AreEqual (EventType.Breakpoint, e.EventType);
198 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
199 e = vm.GetNextEvent ();
200 Assert.AreEqual (EventType.Breakpoint, e.EventType);
201 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
203 /* Clear one of them */
208 e = vm.GetNextEvent ();
209 Assert.AreEqual (EventType.Breakpoint, e.EventType);
210 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
212 /* Clear the other */
217 e = vm.GetNextEvent ();
218 Assert.AreEqual (EventType.Breakpoint, e.EventType);
219 Assert.AreEqual (m2.Name, (e as BreakpointEvent).Method.Name);
223 public void ClearAllBreakpoints () {
226 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp4");
227 Assert.IsNotNull (m);
228 vm.SetBreakpoint (m, 0);
230 MethodMirror m2 = entry_point.DeclaringType.GetMethod ("bp5");
231 Assert.IsNotNull (m2);
232 vm.SetBreakpoint (m2, 0);
234 vm.ClearAllBreakpoints ();
238 e = vm.GetNextEvent ();
239 Assert.IsTrue (!(e is BreakpointEvent));
240 if (e is VMDeathEvent)
245 public void BreakpointOnGShared () {
248 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp6");
249 Assert.IsNotNull (m);
251 vm.SetBreakpoint (m, 0);
255 e = vm.GetNextEvent ();
256 Assert.AreEqual (EventType.Breakpoint, e.EventType);
257 Assert.IsTrue (e is BreakpointEvent);
258 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
262 public void SingleStepping () {
263 Event e = run_until ("single_stepping");
265 var req = vm.CreateStepRequest (e.Thread);
272 e = vm.GetNextEvent ();
273 Assert.IsTrue (e is StepEvent);
274 Assert.AreEqual ("ss1", (e as StepEvent).Method.Name);
278 e = vm.GetNextEvent ();
279 Assert.IsTrue (e is StepEvent);
280 Assert.AreEqual ("single_stepping", (e as StepEvent).Method.Name);
282 // Change to step over
284 req.Depth = StepDepth.Over;
289 e = vm.GetNextEvent ();
290 Assert.IsTrue (e is StepEvent);
291 Assert.AreEqual ("single_stepping", (e as StepEvent).Method.Name);
293 // Change to step over
295 req.Depth = StepDepth.Into;
300 e = vm.GetNextEvent ();
301 Assert.IsTrue (e is StepEvent);
302 Assert.AreEqual ("ss3", (e as StepEvent).Method.Name);
304 // Change to step out
306 req.Depth = StepDepth.Out;
309 // Step back into single_stepping
311 e = vm.GetNextEvent ();
312 Assert.IsTrue (e is StepEvent);
313 Assert.AreEqual ("single_stepping", (e as StepEvent).Method.Name);
316 req.Depth = StepDepth.Into;
321 e = vm.GetNextEvent ();
322 Assert.IsTrue (e is StepEvent);
323 Assert.AreEqual ("ss4", (e as StepEvent).Method.Name);
325 // Change to StepSize.Line
327 req.Depth = StepDepth.Over;
328 req.Size = StepSize.Line;
331 // Step over ss1 (); ss1 ();
333 e = vm.GetNextEvent ();
334 Assert.IsTrue (e is StepEvent);
338 req.Depth = StepDepth.Into;
342 e = vm.GetNextEvent ();
343 Assert.IsTrue (e is StepEvent);
344 Assert.AreEqual ("ss2", (e as StepEvent).Method.Name);
349 e = run_until ("ss5");
351 // Add an assembly filter
352 req.AssemblyFilter = new AssemblyMirror [] { (e as BreakpointEvent).Method.DeclaringType.Assembly };
355 // Step into is_even, skipping the linq stuff
357 e = vm.GetNextEvent ();
358 Assert.IsTrue (e is StepEvent);
359 Assert.AreEqual ("is_even", (e as StepEvent).Method.Name);
361 // FIXME: Check that single stepping works with lock (obj)
367 public void MethodEntryExit () {
368 run_until ("single_stepping");
370 var req1 = vm.CreateMethodEntryRequest ();
371 var req2 = vm.CreateMethodExitRequest ();
377 Event e = vm.GetNextEvent ();
378 Assert.IsTrue (e is MethodEntryEvent);
379 Assert.AreEqual ("ss1", (e as MethodEntryEvent).Method.Name);
382 e = vm.GetNextEvent ();
383 Assert.IsTrue (e is MethodExitEvent);
384 Assert.AreEqual ("ss1", (e as MethodExitEvent).Method.Name);
391 public void CountFilter () {
392 run_until ("single_stepping");
394 MethodMirror m2 = entry_point.DeclaringType.GetMethod ("ss3");
395 Assert.IsNotNull (m2);
396 vm.SetBreakpoint (m2, 0);
398 var req1 = vm.CreateMethodEntryRequest ();
402 // Enter ss2, ss1 is skipped
404 Event e = vm.GetNextEvent ();
405 Assert.IsTrue (e is MethodEntryEvent);
406 Assert.AreEqual ("ss2", (e as MethodEntryEvent).Method.Name);
408 // Breakpoint on ss3, the entry event is no longer reported
410 e = vm.GetNextEvent ();
411 Assert.IsTrue (e is BreakpointEvent);
416 BreakpointEvent run_until (string name) {
418 MethodMirror m = entry_point.DeclaringType.GetMethod (name);
419 Assert.IsNotNull (m);
420 vm.SetBreakpoint (m, 0);
426 e = vm.GetNextEvent ();
427 if (e is BreakpointEvent)
431 Assert.IsInstanceOfType (typeof (BreakpointEvent), e);
432 Assert.AreEqual (m, (e as BreakpointEvent).Method);
434 return (e as BreakpointEvent);
437 Event single_step (ThreadMirror t) {
438 var req = vm.CreateStepRequest (t);
442 Event e = vm.GetNextEvent ();
443 Assert.IsTrue (e is StepEvent);
450 void check_arg_val (StackFrame frame, int pos, Type type, object eval) {
451 object val = frame.GetArgument (pos);
452 Assert.IsTrue (val is PrimitiveValue);
453 object v = (val as PrimitiveValue).Value;
454 Assert.AreEqual (type, v.GetType ());
456 Assert.IsTrue (Math.Abs ((float)eval - (float)v) < 0.0001);
457 else if (eval is double)
458 Assert.IsTrue (Math.Abs ((double)eval - (double)v) < 0.0001);
460 Assert.AreEqual (eval, v);
463 void AssertValue (object expected, object val) {
464 if (expected is string) {
465 Assert.IsTrue (val is StringMirror);
466 Assert.AreEqual (expected, (val as StringMirror).Value);
468 Assert.IsTrue (val is PrimitiveValue);
469 Assert.AreEqual (expected, (val as PrimitiveValue).Value);
474 public void Arguments () {
477 var e = run_until ("arg1");
479 StackFrame frame = e.Thread.GetFrames () [0];
481 check_arg_val (frame, 0, typeof (sbyte), SByte.MaxValue - 5);
482 check_arg_val (frame, 1, typeof (byte), Byte.MaxValue - 5);
483 check_arg_val (frame, 2, typeof (bool), true);
484 check_arg_val (frame, 3, typeof (short), Int16.MaxValue - 5);
485 check_arg_val (frame, 4, typeof (ushort), UInt16.MaxValue - 5);
486 check_arg_val (frame, 5, typeof (char), 'F');
487 check_arg_val (frame, 6, typeof (int), Int32.MaxValue - 5);
488 check_arg_val (frame, 7, typeof (uint), UInt32.MaxValue - 5);
489 check_arg_val (frame, 8, typeof (long), Int64.MaxValue - 5);
490 check_arg_val (frame, 9, typeof (ulong), UInt64.MaxValue - 5);
491 check_arg_val (frame, 10, typeof (float), 1.2345f);
492 check_arg_val (frame, 11, typeof (double), 6.78910);
494 e = run_until ("arg2");
496 frame = e.Thread.GetFrames () [0];
499 val = frame.GetArgument (0);
500 AssertValue ("FOO", val);
501 Assert.AreEqual ("String", (val as ObjectMirror).Type.Name);
504 val = frame.GetArgument (1);
505 AssertValue (null, val);
508 val = frame.GetArgument (2);
509 AssertValue ("BLA", val);
512 val = frame.GetArgument (3);
513 AssertValue (42, val);
516 val = frame.GetArgument (4);
517 Assert.IsTrue (val is ObjectMirror);
518 Assert.AreEqual ("GClass`1", (val as ObjectMirror).Type.Name);
521 val = frame.GetArgument (5);
522 Assert.IsTrue (val is ObjectMirror);
523 Assert.AreEqual ("Object", (val as ObjectMirror).Type.Name);
525 // this on static methods
526 val = frame.GetThis ();
527 AssertValue (null, val);
529 e = run_until ("arg3");
531 frame = e.Thread.GetFrames () [0];
534 val = frame.GetThis ();
535 Assert.IsTrue (val is ObjectMirror);
536 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
538 // objref in register
539 val = frame.GetArgument (0);
540 AssertValue ("BLA", val);
544 public void Arrays () {
547 var e = run_until ("o2");
549 StackFrame frame = e.Thread.GetFrames () [0];
552 val = frame.GetArgument (0);
553 Assert.IsTrue (val is ArrayMirror);
554 ArrayMirror arr = val as ArrayMirror;
555 Assert.AreEqual (2, arr.Length);
556 AssertValue ("BAR", arr [0]);
557 AssertValue ("BAZ", arr [1]);
559 var vals = arr.GetValues (0, 2);
560 Assert.AreEqual (2, vals.Count);
561 AssertValue ("BAR", vals [0]);
562 AssertValue ("BAZ", vals [1]);
564 arr [0] = vm.RootDomain.CreateString ("ABC");
565 AssertValue ("ABC", arr [0]);
567 arr [0] = vm.CreateValue (null);
568 AssertValue (null, arr [0]);
570 arr.SetValues (0, new Value [] { vm.RootDomain.CreateString ("D1"), vm.RootDomain.CreateString ("D2") });
571 AssertValue ("D1", arr [0]);
572 AssertValue ("D2", arr [1]);
575 val = frame.GetArgument (1);
576 Assert.IsTrue (val is ArrayMirror);
577 arr = val as ArrayMirror;
578 Assert.AreEqual (2, arr.Length);
579 AssertValue (42, arr [0]);
580 AssertValue (43, arr [1]);
583 AssertThrows<IndexOutOfRangeException> (delegate () {
587 AssertThrows<IndexOutOfRangeException> (delegate () {
588 val = arr [Int32.MinValue];
591 AssertThrows<IndexOutOfRangeException> (delegate () {
592 vals = arr.GetValues (0, 3);
595 AssertThrows<IndexOutOfRangeException> (delegate () {
596 arr [2] = vm.CreateValue (null);
599 AssertThrows<IndexOutOfRangeException> (delegate () {
600 arr [Int32.MinValue] = vm.CreateValue (null);
603 AssertThrows<IndexOutOfRangeException> (delegate () {
604 arr.SetValues (0, new Value [] { null, null, null });
608 val = frame.GetArgument (2);
609 Assert.IsTrue (val is ArrayMirror);
610 arr = val as ArrayMirror;
611 Assert.AreEqual (2, arr.Rank);
612 Assert.AreEqual (4, arr.Length);
613 Assert.AreEqual (2, arr.GetLength (0));
614 Assert.AreEqual (2, arr.GetLength (1));
615 Assert.AreEqual (0, arr.GetLowerBound (0));
616 Assert.AreEqual (0, arr.GetLowerBound (1));
617 vals = arr.GetValues (0, 4);
618 AssertValue (1, vals [0]);
619 AssertValue (2, vals [1]);
620 AssertValue (3, vals [2]);
621 AssertValue (4, vals [3]);
623 val = frame.GetArgument (3);
624 Assert.IsTrue (val is ArrayMirror);
625 arr = val as ArrayMirror;
626 Assert.AreEqual (2, arr.Rank);
627 Assert.AreEqual (4, arr.Length);
628 Assert.AreEqual (2, arr.GetLength (0));
629 Assert.AreEqual (2, arr.GetLength (1));
630 Assert.AreEqual (1, arr.GetLowerBound (0));
631 Assert.AreEqual (3, arr.GetLowerBound (1));
633 AssertThrows<ArgumentOutOfRangeException> (delegate () {
636 AssertThrows<ArgumentOutOfRangeException> (delegate () {
640 AssertThrows<ArgumentOutOfRangeException> (delegate () {
641 arr.GetLowerBound (-1);
643 AssertThrows<ArgumentOutOfRangeException> (delegate () {
644 arr.GetLowerBound (2);
647 // arrays treated as generic collections
648 val = frame.GetArgument (4);
649 Assert.IsTrue (val is ArrayMirror);
650 arr = val as ArrayMirror;
654 public void Object_GetValue () {
655 var e = run_until ("o1");
656 var frame = e.Thread.GetFrames () [0];
658 object val = frame.GetThis ();
659 Assert.IsTrue (val is ObjectMirror);
660 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
661 ObjectMirror o = (val as ObjectMirror);
663 TypeMirror t = o.Type;
666 object f = o.GetValue (t.GetField ("field_i"));
668 f = o.GetValue (t.GetField ("field_s"));
669 AssertValue ("S", f);
670 f = o.GetValue (t.GetField ("field_enum"));
671 Assert.IsTrue (f is EnumMirror);
672 Assert.AreEqual (1, (f as EnumMirror).Value);
673 Assert.AreEqual ("B", (f as EnumMirror).StringValue);
675 // Inherited object fields
676 TypeMirror parent = t.BaseType;
677 f = o.GetValue (parent.GetField ("base_field_i"));
679 f = o.GetValue (parent.GetField ("base_field_s"));
680 AssertValue ("T", f);
683 f = o.GetValue (o.Type.GetField ("static_i"));
687 ObjectMirror o2 = frame.GetValue (frame.Method.GetParameters ()[1]) as ObjectMirror;
688 Assert.AreEqual ("GClass`1", o2.Type.Name);
689 TypeMirror t2 = o2.Type;
690 f = o2.GetValue (t2.GetField ("field"));
693 ObjectMirror o3 = frame.GetValue (frame.Method.GetParameters ()[2]) as ObjectMirror;
694 Assert.AreEqual ("GClass`1", o3.Type.Name);
695 TypeMirror t3 = o3.Type;
696 f = o3.GetValue (t3.GetField ("field"));
697 AssertValue ("FOO", f);
700 AssertThrows<ArgumentNullException> (delegate () {
706 public void Object_GetValues () {
707 var e = run_until ("o1");
708 var frame = e.Thread.GetFrames () [0];
710 object val = frame.GetThis ();
711 Assert.IsTrue (val is ObjectMirror);
712 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
713 ObjectMirror o = (val as ObjectMirror);
715 ObjectMirror val2 = frame.GetValue (frame.Method.GetParameters ()[0]) as ObjectMirror;
717 TypeMirror t = o.Type;
719 object[] vals = o.GetValues (new FieldInfoMirror [] { t.GetField ("field_i"), t.GetField ("field_s") });
723 AssertValue ("S", f);
726 AssertThrows<ArgumentNullException> (delegate () {
730 AssertThrows<ArgumentNullException> (delegate () {
731 o.GetValues (new FieldInfoMirror [] { null });
734 // field of another class
735 AssertThrows<ArgumentException> (delegate () {
736 o.GetValue (val2.Type.GetField ("field_j"));
740 void TestSetValue (ObjectMirror o, string field_name, object val) {
742 o.SetValue (o.Type.GetField (field_name), vm.RootDomain.CreateString ((string)val));
744 o.SetValue (o.Type.GetField (field_name), vm.CreateValue (val));
745 Value f = o.GetValue (o.Type.GetField (field_name));
746 AssertValue (val, f);
750 public void Object_SetValues () {
751 var e = run_until ("o1");
752 var frame = e.Thread.GetFrames () [0];
754 object val = frame.GetThis ();
755 Assert.IsTrue (val is ObjectMirror);
756 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
757 ObjectMirror o = (val as ObjectMirror);
759 ObjectMirror val2 = frame.GetValue (frame.Method.GetParameters ()[0]) as ObjectMirror;
761 TestSetValue (o, "field_i", 22);
762 TestSetValue (o, "field_bool1", false);
763 TestSetValue (o, "field_bool2", true);
764 TestSetValue (o, "field_char", 'B');
765 TestSetValue (o, "field_byte", (byte)129);
766 TestSetValue (o, "field_sbyte", (sbyte)-33);
767 TestSetValue (o, "field_short", (short)(Int16.MaxValue - 5));
768 TestSetValue (o, "field_ushort", (ushort)(UInt16.MaxValue - 5));
769 TestSetValue (o, "field_long", Int64.MaxValue - 5);
770 TestSetValue (o, "field_ulong", (ulong)(UInt64.MaxValue - 5));
771 TestSetValue (o, "field_float", 6.28f);
772 TestSetValue (o, "field_double", 6.28);
773 TestSetValue (o, "static_i", 23);
774 TestSetValue (o, "field_s", "CDEF");
779 f = o.GetValue (o.Type.GetField ("field_enum"));
780 (f as EnumMirror).Value = 5;
781 o.SetValue (o.Type.GetField ("field_enum"), f);
782 f = o.GetValue (o.Type.GetField ("field_enum"));
783 Assert.AreEqual (5, (f as EnumMirror).Value);
786 o.SetValue (o.Type.GetField ("field_s"), vm.CreateValue (null));
787 f = o.GetValue (o.Type.GetField ("field_s"));
788 AssertValue (null, f);
791 AssertThrows<ArgumentNullException> (delegate () {
792 o.SetValues (null, new Value [0]);
795 AssertThrows<ArgumentNullException> (delegate () {
796 o.SetValues (new FieldInfoMirror [0], null);
799 AssertThrows<ArgumentNullException> (delegate () {
800 o.SetValues (new FieldInfoMirror [] { null }, new Value [1] { null });
803 // vtype with a wrong type
804 AssertThrows<ArgumentException> (delegate () {
805 o.SetValue (o.Type.GetField ("field_struct"), o.GetValue (o.Type.GetField ("field_enum")));
808 // reference type not assignment compatible
809 AssertThrows<ArgumentException> (delegate () {
810 o.SetValue (o.Type.GetField ("field_class"), o);
813 // field of another class
814 AssertThrows<ArgumentException> (delegate () {
815 o.SetValue (val2.Type.GetField ("field_j"), vm.CreateValue (1));
820 public void Type_SetValue () {
821 var e = run_until ("o1");
822 var frame = e.Thread.GetFrames () [0];
825 object val = frame.GetThis ();
826 Assert.IsTrue (val is ObjectMirror);
827 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
828 ObjectMirror o = (val as ObjectMirror);
830 ObjectMirror val2 = frame.GetValue (frame.Method.GetParameters ()[0]) as ObjectMirror;
832 o.Type.SetValue (o.Type.GetField ("static_i"), vm.CreateValue (55));
833 f = o.Type.GetValue (o.Type.GetField ("static_i"));
837 AssertThrows<ArgumentNullException> (delegate () {
838 o.Type.SetValue (null, vm.CreateValue (0));
841 AssertThrows<ArgumentNullException> (delegate () {
842 o.Type.SetValue (o.Type.GetField ("static_i"), null);
845 // field of another class
846 AssertThrows<ArgumentException> (delegate () {
847 o.SetValue (val2.Type.GetField ("field_j"), vm.CreateValue (1));
852 public void TypeInfo () {
853 Event e = run_until ("ti2");
854 StackFrame frame = e.Thread.GetFrames () [0];
859 t = frame.Method.GetParameters ()[0].ParameterType;
861 Assert.AreEqual ("String[]", t.Name);
862 Assert.AreEqual ("string[]", t.CSharpName);
863 Assert.AreEqual ("Array", t.BaseType.Name);
864 Assert.AreEqual (true, t.HasElementType);
865 Assert.AreEqual (true, t.IsArray);
866 Assert.AreEqual (1, t.GetArrayRank ());
867 Assert.AreEqual ("String", t.GetElementType ().Name);
869 t = frame.Method.GetParameters ()[2].ParameterType;
871 Assert.AreEqual ("Int32[,]", t.Name);
873 //Assert.AreEqual ("int[,]", t.CSharpName);
874 Assert.AreEqual ("Array", t.BaseType.Name);
875 Assert.AreEqual (true, t.HasElementType);
876 Assert.AreEqual (true, t.IsArray);
877 Assert.AreEqual (2, t.GetArrayRank ());
878 Assert.AreEqual ("Int32", t.GetElementType ().Name);
881 t = frame.Method.GetParameters ()[3].ParameterType;
883 //Assert.AreEqual ("Int32&", t.Name);
884 //Assert.AreEqual (true, t.IsByRef);
885 //Assert.AreEqual (true, t.HasElementType);
888 t = frame.Method.GetParameters ()[4].ParameterType;
890 //Assert.AreEqual ("Int32*", t.Name);
891 Assert.AreEqual (true, t.IsPointer);
892 Assert.AreEqual (true, t.HasElementType);
893 Assert.AreEqual ("Int32", t.GetElementType ().Name);
894 Assert.AreEqual (false, t.IsPrimitive);
897 t = frame.Method.GetParameters ()[5].ParameterType;
898 Assert.AreEqual (true, t.IsPrimitive);
901 t = frame.Method.GetParameters ()[6].ParameterType;
902 Assert.AreEqual ("AStruct", t.Name);
903 Assert.AreEqual (false, t.IsPrimitive);
904 Assert.AreEqual (true, t.IsValueType);
905 Assert.AreEqual (false, t.IsClass);
908 t = frame.Method.GetParameters ()[7].ParameterType;
909 Assert.AreEqual ("Tests", t.Name);
910 var nested = t.GetNestedTypes ();
911 Assert.AreEqual (1, nested.Length);
912 Assert.AreEqual ("NestedClass", nested [0].Name);
913 Assert.IsTrue (t.BaseType.IsAssignableFrom (t));
914 Assert.IsTrue (!t.IsAssignableFrom (t.BaseType));
917 t = frame.Method.GetParameters ()[9].ParameterType;
918 Assert.AreEqual ("GClass`1", t.Name);
921 t = frame.Method.GetParameters ()[7].ParameterType;
923 var props = t.GetProperties ();
924 Assert.AreEqual (3, props.Length);
925 foreach (PropertyInfoMirror prop in props) {
926 ParameterInfoMirror[] indexes = prop.GetIndexParameters ();
928 if (prop.Name == "IntProperty") {
929 Assert.AreEqual ("Int32", prop.PropertyType.Name);
930 Assert.AreEqual ("get_IntProperty", prop.GetGetMethod ().Name);
931 Assert.AreEqual ("set_IntProperty", prop.GetSetMethod ().Name);
932 Assert.AreEqual (0, indexes.Length);
933 } else if (prop.Name == "ReadOnlyProperty") {
934 Assert.AreEqual ("Int32", prop.PropertyType.Name);
935 Assert.AreEqual ("get_ReadOnlyProperty", prop.GetGetMethod ().Name);
936 Assert.AreEqual (null, prop.GetSetMethod ());
937 Assert.AreEqual (0, indexes.Length);
938 } else if (prop.Name == "IndexedProperty") {
939 Assert.AreEqual (1, indexes.Length);
940 Assert.AreEqual ("Int32", indexes [0].ParameterType.Name);
945 t = frame.Method.GetParameters ()[8].ParameterType;
946 Assert.AreEqual ("Tests2", t.Name);
947 var attrs = t.GetCustomAttributes (true);
948 Assert.AreEqual (2, attrs.Length);
949 foreach (var attr in attrs) {
950 if (attr.Constructor.DeclaringType.Name == "DebuggerDisplayAttribute") {
951 Assert.AreEqual (1, attr.ConstructorArguments.Count);
952 Assert.AreEqual ("Tests", attr.ConstructorArguments [0].Value);
953 Assert.AreEqual (2, attr.NamedArguments.Count);
954 Assert.AreEqual ("Name", attr.NamedArguments [0].Property.Name);
955 Assert.AreEqual ("FOO", attr.NamedArguments [0].TypedValue.Value);
956 Assert.AreEqual ("Target", attr.NamedArguments [1].Property.Name);
957 Assert.IsInstanceOfType (typeof (TypeMirror), attr.NamedArguments [1].TypedValue.Value);
958 Assert.AreEqual ("Int32", (attr.NamedArguments [1].TypedValue.Value as TypeMirror).Name);
959 } else if (attr.Constructor.DeclaringType.Name == "DebuggerTypeProxyAttribute") {
960 Assert.AreEqual (1, attr.ConstructorArguments.Count);
961 Assert.IsInstanceOfType (typeof (TypeMirror), attr.ConstructorArguments [0].Value);
962 Assert.AreEqual ("Tests", (attr.ConstructorArguments [0].Value as TypeMirror).Name);
964 Assert.Fail (attr.Constructor.DeclaringType.Name);
970 public void FieldInfo () {
971 Event e = run_until ("ti2");
972 StackFrame frame = e.Thread.GetFrames () [0];
976 t = frame.Method.GetParameters ()[8].ParameterType;
977 Assert.AreEqual ("Tests2", t.Name);
979 var fi = t.GetField ("field_j");
980 var attrs = fi.GetCustomAttributes (true);
981 Assert.AreEqual (1, attrs.Length);
982 var attr = attrs [0];
983 Assert.AreEqual ("DebuggerBrowsableAttribute", attr.Constructor.DeclaringType.Name);
984 Assert.AreEqual (1, attr.ConstructorArguments.Count);
985 Assert.IsInstanceOfType (typeof (EnumMirror), attr.ConstructorArguments [0].Value);
986 Assert.AreEqual ((int)System.Diagnostics.DebuggerBrowsableState.Collapsed, (attr.ConstructorArguments [0].Value as EnumMirror).Value);
990 public void PropertyInfo () {
991 Event e = run_until ("ti2");
992 StackFrame frame = e.Thread.GetFrames () [0];
996 t = frame.Method.GetParameters ()[8].ParameterType;
997 Assert.AreEqual ("Tests2", t.Name);
999 var pi = t.GetProperty ("AProperty");
1000 var attrs = pi.GetCustomAttributes (true);
1001 Assert.AreEqual (1, attrs.Length);
1002 var attr = attrs [0];
1003 Assert.AreEqual ("DebuggerBrowsableAttribute", attr.Constructor.DeclaringType.Name);
1004 Assert.AreEqual (1, attr.ConstructorArguments.Count);
1005 Assert.IsInstanceOfType (typeof (EnumMirror), attr.ConstructorArguments [0].Value);
1006 Assert.AreEqual ((int)System.Diagnostics.DebuggerBrowsableState.Collapsed, (attr.ConstructorArguments [0].Value as EnumMirror).Value);
1010 public void Type_GetValue () {
1011 Event e = run_until ("o1");
1012 StackFrame frame = e.Thread.GetFrames () [0];
1014 ObjectMirror o = (frame.GetThis () as ObjectMirror);
1016 TypeMirror t = o.Type;
1018 ObjectMirror val2 = frame.GetValue (frame.Method.GetParameters ()[0]) as ObjectMirror;
1021 object f = t.GetValue (o.Type.GetField ("static_i"));
1022 AssertValue (55, f);
1024 f = t.GetValue (o.Type.GetField ("static_s"));
1025 AssertValue ("A", f);
1027 // literal static fields
1028 f = t.GetValue (o.Type.GetField ("literal_i"));
1029 AssertValue (56, f);
1031 f = t.GetValue (o.Type.GetField ("literal_s"));
1032 AssertValue ("B", f);
1034 // Inherited static fields
1035 TypeMirror parent = t.BaseType;
1036 f = t.GetValue (parent.GetField ("base_static_i"));
1037 AssertValue (57, f);
1039 f = t.GetValue (parent.GetField ("base_static_s"));
1040 AssertValue ("C", f);
1042 // Argument checking
1043 AssertThrows<ArgumentNullException> (delegate () {
1048 AssertThrows<ArgumentException> (delegate () {
1049 t.GetValue (o.Type.GetField ("field_i"));
1052 // field on another type
1053 AssertThrows<ArgumentException> (delegate () {
1054 t.GetValue (val2.Type.GetField ("static_field_j"));
1057 // special static field
1058 AssertThrows<ArgumentException> (delegate () {
1059 t.GetValue (t.GetField ("tls_i"));
1064 public void Type_GetValues () {
1065 Event e = run_until ("o1");
1066 StackFrame frame = e.Thread.GetFrames () [0];
1068 ObjectMirror o = (frame.GetThis () as ObjectMirror);
1070 TypeMirror t = o.Type;
1073 object[] vals = t.GetValues (new FieldInfoMirror [] { t.GetField ("static_i"), t.GetField ("static_s") });
1074 object f = vals [0];
1075 AssertValue (55, f);
1078 AssertValue ("A", f);
1080 // Argument checking
1081 AssertThrows<ArgumentNullException> (delegate () {
1085 AssertThrows<ArgumentNullException> (delegate () {
1086 t.GetValues (new FieldInfoMirror [] { null });
1091 public void ObjRefs () {
1092 Event e = run_until ("objrefs1");
1093 StackFrame frame = e.Thread.GetFrames () [0];
1095 ObjectMirror o = frame.GetThis () as ObjectMirror;
1096 ObjectMirror child = o.GetValue (o.Type.GetField ("child")) as ObjectMirror;
1098 Assert.IsTrue (child.Address > 0);
1100 // Check that object references are internalized correctly
1101 Assert.AreEqual (o, frame.GetThis ());
1103 run_until ("objrefs2");
1105 // child should be gc'd now
1106 Assert.IsTrue (child.IsCollected);
1108 AssertThrows<ObjectCollectedException> (delegate () {
1109 TypeMirror t = child.Type;
1112 AssertThrows<ObjectCollectedException> (delegate () {
1113 long addr = child.Address;
1118 public void Type_GetObject () {
1119 Event e = run_until ("o1");
1120 StackFrame frame = e.Thread.GetFrames () [0];
1122 ObjectMirror o = (frame.GetThis () as ObjectMirror);
1124 TypeMirror t = o.Type;
1126 Assert.AreEqual ("MonoType", t.GetTypeObject ().Type.Name);
1130 public void VTypes () {
1131 Event e = run_until ("vtypes1");
1132 StackFrame frame = e.Thread.GetFrames () [0];
1135 ObjectMirror o = frame.GetThis () as ObjectMirror;
1136 var obj = o.GetValue (o.Type.GetField ("field_struct"));
1137 Assert.IsTrue (obj is StructMirror);
1138 var s = obj as StructMirror;
1139 Assert.AreEqual ("AStruct", s.Type.Name);
1140 AssertValue (42, s ["i"]);
1142 AssertValue ("S", obj);
1143 AssertValue (43, s ["k"]);
1144 obj = o.GetValue (o.Type.GetField ("field_boxed_struct"));
1145 Assert.IsTrue (obj is StructMirror);
1146 s = obj as StructMirror;
1147 Assert.AreEqual ("AStruct", s.Type.Name);
1148 AssertValue (42, s ["i"]);
1150 // vtypes as arguments
1151 s = frame.GetArgument (0) as StructMirror;
1152 AssertValue (44, s ["i"]);
1154 AssertValue ("T", obj);
1155 AssertValue (45, s ["k"]);
1157 // vtypes as array entries
1158 var arr = frame.GetArgument (1) as ArrayMirror;
1160 Assert.IsTrue (obj is StructMirror);
1161 s = obj as StructMirror;
1162 AssertValue (1, s ["i"]);
1163 AssertValue ("S1", s ["s"]);
1165 Assert.IsTrue (obj is StructMirror);
1166 s = obj as StructMirror;
1167 AssertValue (2, s ["i"]);
1168 AssertValue ("S2", s ["s"]);
1170 // Argument checking
1171 s = frame.GetArgument (0) as StructMirror;
1172 AssertThrows<ArgumentException> (delegate () {
1176 // generic vtype instances
1177 o = frame.GetThis () as ObjectMirror;
1178 obj = o.GetValue (o.Type.GetField ("generic_field_struct"));
1179 Assert.IsTrue (obj is StructMirror);
1180 s = obj as StructMirror;
1181 Assert.AreEqual ("GStruct`1", s.Type.Name);
1182 AssertValue (42, s ["i"]);
1184 // this on vtype methods
1185 e = run_until ("vtypes2");
1187 e = single_step (e.Thread);
1189 frame = e.Thread.GetFrames () [0];
1191 Assert.AreEqual ("foo", (e as StepEvent).Method.Name);
1192 obj = frame.GetThis ();
1194 Assert.IsTrue (obj is StructMirror);
1195 s = obj as StructMirror;
1196 AssertValue (44, s ["i"]);
1197 AssertValue ("T", s ["s"]);
1198 AssertValue (45, s ["k"]);
1200 // this on static vtype methods
1201 e = run_until ("vtypes3");
1203 e = single_step (e.Thread);
1205 frame = e.Thread.GetFrames () [0];
1207 Assert.AreEqual ("static_foo", (e as StepEvent).Method.Name);
1208 obj = frame.GetThis ();
1209 AssertValue (null, obj);
1213 public void Modules () {
1214 Event e = run_until ("single_stepping");
1216 StackFrame frame = e.Thread.GetFrames () [0];
1218 ModuleMirror m = frame.Method.DeclaringType.Module;
1220 Assert.AreEqual ("dtest-app.exe", m.Name);
1221 Assert.AreEqual ("dtest-app.exe", m.ScopeName);
1222 Assert.IsTrue (m.FullyQualifiedName.IndexOf ("dtest-app.exe") != -1);
1223 Guid guid = m.ModuleVersionId;
1224 Assert.AreEqual (frame.Method.DeclaringType.Assembly, m.Assembly);
1225 Assert.AreEqual (frame.Method.DeclaringType.Assembly.ManifestModule, m);
1227 Assert.AreEqual ("Assembly", frame.Method.DeclaringType.Assembly.GetAssemblyObject ().Type.Name);
1229 TypeMirror t = vm.RootDomain.Corlib.GetType ("System.Diagnostics.DebuggerDisplayAttribute", false, false);
1230 Assert.AreEqual ("DebuggerDisplayAttribute", t.Name);
1234 public void LocalsInfo () {
1235 Event e = run_until ("locals2");
1237 StackFrame frame = e.Thread.GetFrames () [0];
1239 var locals = frame.Method.GetLocals ();
1240 Assert.AreEqual (5, locals.Length);
1241 for (int i = 0; i < 5; ++i) {
1242 if (locals [i].Name == "args") {
1243 Assert.IsTrue (locals [i].IsArg);
1244 Assert.AreEqual ("String[]", locals [i].Type.Name);
1245 } else if (locals [i].Name == "arg") {
1246 Assert.IsTrue (locals [i].IsArg);
1247 Assert.AreEqual ("Int32", locals [i].Type.Name);
1248 } else if (locals [i].Name == "i") {
1249 Assert.IsFalse (locals [i].IsArg);
1250 Assert.AreEqual ("Int64", locals [i].Type.Name);
1251 } else if (locals [i].Name == "j") {
1252 Assert.IsFalse (locals [i].IsArg);
1253 Assert.AreEqual ("Int32", locals [i].Type.Name);
1254 } else if (locals [i].Name == "s") {
1255 Assert.IsFalse (locals [i].IsArg);
1256 Assert.AreEqual ("String", locals [i].Type.Name);
1264 public void Locals () {
1265 var be = run_until ("locals1");
1267 StackFrame frame = be.Thread.GetFrames () [0];
1269 MethodMirror m1 = frame.Method;
1271 be = run_until ("locals2");
1273 frame = be.Thread.GetFrames () [0];
1275 object val = frame.GetValue (frame.Method.GetLocal ("i"));
1276 AssertValue (0, val);
1279 var req = vm.CreateStepRequest (be.Thread);
1283 var e = vm.GetNextEvent ();
1284 Assert.IsTrue (e is StepEvent);
1285 Assert.AreEqual ("locals2", (e as StepEvent).Method.Name);
1287 // Execute s = "AB";
1289 e = vm.GetNextEvent ();
1290 Assert.IsTrue (e is StepEvent);
1291 Assert.AreEqual ("locals2", (e as StepEvent).Method.Name);
1293 frame = e.Thread.GetFrames () [0];
1295 val = frame.GetValue (frame.Method.GetLocal ("i"));
1296 AssertValue (42, val);
1298 LocalVariable[] locals = frame.Method.GetLocals ();
1299 var vals = frame.GetValues (locals);
1300 Assert.AreEqual (locals.Length, vals.Length);
1301 for (int i = 0; i < locals.Length; ++i) {
1302 if (locals [i].Name == "i")
1303 AssertValue (42, vals [i]);
1304 if (locals [i].Name == "s")
1305 AssertValue ("AB", vals [i]);
1308 // Argument checking
1311 AssertThrows<ArgumentNullException> (delegate () {
1312 frame.GetValue ((LocalVariable)null);
1314 // GetValue () local from another method
1315 AssertThrows<ArgumentException> (delegate () {
1316 frame.GetValue (m1.GetLocal ("foo"));
1320 AssertThrows<ArgumentNullException> (delegate () {
1321 frame.GetValue ((ParameterInfoMirror)null);
1323 // GetValue () local from another method
1324 AssertThrows<ArgumentException> (delegate () {
1325 frame.GetValue (m1.GetParameters ()[0]);
1328 // GetValues () null
1329 AssertThrows<ArgumentNullException> (delegate () {
1330 frame.GetValues (null);
1332 // GetValues () embedded null
1333 AssertThrows<ArgumentNullException> (delegate () {
1334 frame.GetValues (new LocalVariable [] { null });
1336 // GetValues () local from another method
1337 AssertThrows<ArgumentException> (delegate () {
1338 frame.GetValues (new LocalVariable [] { m1.GetLocal ("foo") });
1341 AssertThrows<ArgumentException> (delegate () {
1342 val = frame.GetValue (frame.Method.ReturnParameter);
1345 // invalid stack frames
1347 e = vm.GetNextEvent ();
1348 Assert.IsTrue (e is StepEvent);
1349 Assert.AreEqual ("locals2", (e as StepEvent).Method.Name);
1351 AssertThrows<InvalidStackFrameException> (delegate () {
1352 frame.GetValue (frame.Method.GetLocal ("i"));
1359 public void Exit () {
1364 var e = vm.GetNextEvent ();
1365 Assert.IsInstanceOfType (typeof (VMDeathEvent), e);
1368 /* Could be a remote vm with no process */
1371 Assert.AreEqual (5, p.ExitCode);
1374 AssertThrows<VMDisconnectedException> (delegate () {
1383 public void Dispose () {
1388 var e = vm.GetNextEvent ();
1389 Assert.IsInstanceOfType (typeof (VMDisconnectEvent), e);
1392 /* Could be a remote vm with no process */
1395 Assert.AreEqual (3, p.ExitCode);
1398 AssertThrows<VMDisconnectedException> (delegate () {
1407 public void LineNumbers () {
1408 Event e = run_until ("line_numbers");
1410 step_req = vm.CreateStepRequest (e.Thread);
1411 step_req.Depth = StepDepth.Into;
1418 e = vm.GetNextEvent ();
1419 Assert.IsTrue (e is StepEvent);
1421 l = e.Thread.GetFrames ()[0].Location;
1423 Assert.IsTrue (l.SourceFile.IndexOf ("dtest-app.cs") != -1);
1424 Assert.AreEqual ("ln1", l.Method.Name);
1426 int line_base = l.LineNumber;
1429 e = vm.GetNextEvent ();
1430 Assert.IsTrue (e is StepEvent);
1431 l = e.Thread.GetFrames ()[0].Location;
1432 Assert.AreEqual ("ln2", l.Method.Name);
1433 Assert.AreEqual (line_base + 6, l.LineNumber);
1436 e = vm.GetNextEvent ();
1437 Assert.IsTrue (e is StepEvent);
1438 l = e.Thread.GetFrames ()[0].Location;
1439 Assert.AreEqual ("ln1", l.Method.Name);
1440 Assert.AreEqual (line_base + 1, l.LineNumber);
1443 e = vm.GetNextEvent ();
1444 Assert.IsTrue (e is StepEvent);
1445 l = e.Thread.GetFrames ()[0].Location;
1446 Assert.AreEqual ("ln3", l.Method.Name);
1447 Assert.AreEqual (line_base + 10, l.LineNumber);
1450 e = vm.GetNextEvent ();
1451 Assert.IsTrue (e is StepEvent);
1452 l = e.Thread.GetFrames ()[0].Location;
1453 Assert.AreEqual ("ln1", l.Method.Name);
1454 Assert.AreEqual (line_base + 2, l.LineNumber);
1456 // GetSourceFiles ()
1457 string[] sources = l.Method.DeclaringType.GetSourceFiles ();
1458 Assert.AreEqual (1, sources.Length);
1459 Assert.AreEqual ("dtest-app.cs", sources [0]);
1463 public void Suspend () {
1466 Start (new string [] { "dtest-app.exe", "suspend-test" });
1468 Event e = run_until ("suspend");
1470 ThreadMirror main = e.Thread;
1478 // The debuggee should be suspended while it is running the infinite loop
1480 StackFrame frame = main.GetFrames ()[0];
1481 Assert.AreEqual ("suspend", frame.Method.Name);
1485 // resuming when not suspended
1486 AssertThrows<InvalidOperationException> (delegate () {
1496 public void AssemblyLoad () {
1497 Event e = run_until ("assembly_load");
1501 e = vm.GetNextEvent ();
1502 Assert.IsInstanceOfType (typeof (AssemblyLoadEvent), e);
1503 Assert.IsTrue ((e as AssemblyLoadEvent).Assembly.Location.EndsWith ("System.dll"));
1505 var frames = e.Thread.GetFrames ();
1506 Assert.IsTrue (frames.Length > 0);
1507 Assert.AreEqual ("assembly_load", frames [0].Method.Name);
1511 public void CreateValue () {
1514 v = vm.CreateValue (1);
1515 Assert.AreEqual (vm, v.VirtualMachine);
1516 Assert.AreEqual (1, v.Value);
1518 v = vm.CreateValue (null);
1519 Assert.AreEqual (vm, v.VirtualMachine);
1520 Assert.AreEqual (null, v.Value);
1522 // Argument checking
1523 AssertThrows <ArgumentException> (delegate () {
1524 v = vm.CreateValue ("FOO");
1529 public void CreateString () {
1530 StringMirror s = vm.RootDomain.CreateString ("ABC");
1532 Assert.AreEqual (vm, s.VirtualMachine);
1533 Assert.AreEqual ("ABC", s.Value);
1534 Assert.AreEqual (vm.RootDomain, s.Domain);
1536 // Argument checking
1537 AssertThrows <ArgumentNullException> (delegate () {
1538 s = vm.RootDomain.CreateString (null);
1543 public void Invoke () {
1544 Event e = run_until ("invoke1");
1546 StackFrame frame = e.Thread.GetFrames () [0];
1548 TypeMirror t = frame.Method.DeclaringType;
1549 ObjectMirror this_obj = (ObjectMirror)frame.GetThis ();
1551 TypeMirror t2 = frame.Method.GetParameters ()[0].ParameterType;
1557 m = t.GetMethod ("invoke_return_void");
1558 v = this_obj.InvokeMethod (e.Thread, m, null);
1562 m = t.GetMethod ("invoke_return_ref");
1563 v = this_obj.InvokeMethod (e.Thread, m, null);
1564 AssertValue ("ABC", v);
1567 m = t.GetMethod ("invoke_return_null");
1568 v = this_obj.InvokeMethod (e.Thread, m, null);
1569 AssertValue (null, v);
1572 m = t.GetMethod ("invoke_return_primitive");
1573 v = this_obj.InvokeMethod (e.Thread, m, null);
1574 AssertValue (42, v);
1577 m = t.GetMethod ("invoke_pass_primitive");
1578 Value[] args = new Value [] {
1579 vm.CreateValue ((byte)Byte.MaxValue),
1580 vm.CreateValue ((sbyte)SByte.MaxValue),
1581 vm.CreateValue ((short)1),
1582 vm.CreateValue ((ushort)1),
1583 vm.CreateValue ((int)1),
1584 vm.CreateValue ((uint)1),
1585 vm.CreateValue ((long)1),
1586 vm.CreateValue ((ulong)1),
1587 vm.CreateValue ('A'),
1588 vm.CreateValue (true),
1589 vm.CreateValue (3.14f),
1590 vm.CreateValue (3.14) };
1592 v = this_obj.InvokeMethod (e.Thread, m, args);
1593 AssertValue ((int)Byte.MaxValue + (int)SByte.MaxValue + 1 + 1 + 1 + 1 + 1 + 1 + 'A' + 1 + 3 + 3, v);
1596 m = t.GetMethod ("invoke_pass_ref");
1597 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
1598 AssertValue ("ABC", v);
1601 m = t.GetMethod ("invoke_pass_ref");
1602 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.CreateValue (null) });
1603 AssertValue (null, v);
1606 m = t.GetMethod ("invoke_static_pass_ref");
1607 v = t.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
1608 AssertValue ("ABC", v);
1610 // static invoked using ObjectMirror.InvokeMethod
1611 m = t.GetMethod ("invoke_static_pass_ref");
1612 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
1613 AssertValue ("ABC", v);
1615 // method which throws an exception
1617 m = t.GetMethod ("invoke_throws");
1618 v = this_obj.InvokeMethod (e.Thread, m, null);
1620 } catch (InvocationException ex) {
1621 Assert.AreEqual ("Exception", ex.Exception.Type.Name);
1625 m = t.GetMethod (".ctor");
1626 v = t.InvokeMethod (e.Thread, m, null);
1627 Assert.IsInstanceOfType (typeof (ObjectMirror), v);
1628 Assert.AreEqual ("Tests", (v as ObjectMirror).Type.Name);
1630 // Argument checking
1633 AssertThrows<ArgumentNullException> (delegate {
1634 m = t.GetMethod ("invoke_pass_ref");
1635 v = this_obj.InvokeMethod (null, m, new Value [] { vm.CreateValue (null) });
1639 AssertThrows<ArgumentNullException> (delegate {
1640 v = this_obj.InvokeMethod (e.Thread, null, new Value [] { vm.CreateValue (null) });
1643 // invalid number of arguments
1644 m = t.GetMethod ("invoke_pass_ref");
1645 AssertThrows<ArgumentException> (delegate {
1646 v = this_obj.InvokeMethod (e.Thread, m, null);
1649 // invalid type of argument (ref != primitive)
1650 m = t.GetMethod ("invoke_pass_ref");
1651 AssertThrows<ArgumentException> (delegate {
1652 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.CreateValue (1) });
1655 // invalid type of argument (primitive != primitive)
1656 m = t.GetMethod ("invoke_pass_primitive_2");
1657 AssertThrows<ArgumentException> (delegate {
1658 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.CreateValue (1) });
1661 // invoking a non-static method as static
1662 m = t.GetMethod ("invoke_pass_ref");
1663 AssertThrows<ArgumentException> (delegate {
1664 v = t.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
1667 // invoking a method defined in another class
1668 m = t2.GetMethod ("invoke");
1669 AssertThrows<ArgumentException> (delegate {
1670 v = this_obj.InvokeMethod (e.Thread, m, null);
1675 public void InvokeVType () {
1676 Event e = run_until ("invoke1");
1678 StackFrame frame = e.Thread.GetFrames () [0];
1680 var s = frame.GetArgument (1) as StructMirror;
1682 TypeMirror t = s.Type;
1688 m = t.GetMethod ("invoke_return_int");
1689 v = s.InvokeMethod (e.Thread, m, null);
1690 AssertValue (42, v);
1694 public void BreakpointDuringInvoke () {
1695 Event e = run_until ("invoke1");
1697 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke2");
1698 Assert.IsNotNull (m);
1699 vm.SetBreakpoint (m, 0);
1701 StackFrame frame = e.Thread.GetFrames () [0];
1702 var o = frame.GetThis () as ObjectMirror;
1704 bool failed = false;
1706 bool finished = false;
1707 object wait = new object ();
1709 // Have to invoke in a separate thread as the invoke is suspended until we
1710 // resume after the breakpoint
1711 Thread t = new Thread (delegate () {
1713 o.InvokeMethod (e.Thread, m, null);
1719 Monitor.Pulse (wait);
1725 StackFrame invoke_frame = null;
1728 e = vm.GetNextEvent ();
1729 Assert.IsInstanceOfType (typeof (BreakpointEvent), e);
1730 // Check stack trace support and invokes
1731 var frames = e.Thread.GetFrames ();
1732 invoke_frame = frames [0];
1733 Assert.AreEqual ("invoke2", frames [0].Method.Name);
1734 Assert.IsTrue (frames [0].IsDebuggerInvoke);
1735 Assert.AreEqual ("invoke1", frames [1].Method.Name);
1740 // Check that the invoke frames are no longer valid
1741 AssertThrows<InvalidStackFrameException> (delegate {
1742 invoke_frame.GetThis ();
1747 Monitor.Wait (wait);
1752 public void GetThreads () {
1757 public void Threads () {
1758 Event e = run_until ("threads");
1760 Assert.AreEqual (ThreadState.Running, e.Thread.ThreadState);
1762 vm.EnableEvents (EventType.ThreadStart, EventType.ThreadDeath);
1766 e = vm.GetNextEvent ();
1767 Assert.IsInstanceOfType (typeof (ThreadStartEvent), e);
1768 var state = e.Thread.ThreadState;
1769 Assert.IsTrue (state == ThreadState.Running || state == ThreadState.Unstarted);
1773 e = vm.GetNextEvent ();
1774 Assert.IsInstanceOfType (typeof (ThreadDeathEvent), e);
1775 Assert.AreEqual (ThreadState.Stopped, e.Thread.ThreadState);
1779 public void Frame_SetValue () {
1780 Event e = run_until ("locals2");
1782 StackFrame frame = e.Thread.GetFrames () [0];
1785 var l = frame.Method.GetLocal ("i");
1786 frame.SetValue (l, vm.CreateValue ((long)55));
1787 AssertValue (55, frame.GetValue (l));
1790 l = frame.Method.GetLocal ("s");
1791 frame.SetValue (l, vm.RootDomain.CreateString ("DEF"));
1792 AssertValue ("DEF", frame.GetValue (l));
1794 // argument as local
1795 l = frame.Method.GetLocal ("arg");
1796 frame.SetValue (l, vm.CreateValue (6));
1797 AssertValue (6, frame.GetValue (l));
1800 var p = frame.Method.GetParameters ()[1];
1801 frame.SetValue (p, vm.CreateValue (7));
1802 AssertValue (7, frame.GetValue (p));
1804 // argument checking
1807 AssertThrows<ArgumentNullException> (delegate () {
1808 frame.SetValue ((LocalVariable)null, vm.CreateValue (55));
1812 AssertThrows<ArgumentNullException> (delegate () {
1813 l = frame.Method.GetLocal ("i");
1814 frame.SetValue (l, null);
1817 // value of invalid type
1818 AssertThrows<ArgumentException> (delegate () {
1819 l = frame.Method.GetLocal ("i");
1820 frame.SetValue (l, vm.CreateValue (55));
1825 public void InvokeRegress () {
1826 Event e = run_until ("invoke1");
1828 StackFrame frame = e.Thread.GetFrames () [0];
1830 TypeMirror t = frame.Method.DeclaringType;
1831 ObjectMirror this_obj = (ObjectMirror)frame.GetThis ();
1833 TypeMirror t2 = frame.Method.GetParameters ()[0].ParameterType;
1839 m = t.GetMethod ("invoke_return_void");
1840 v = this_obj.InvokeMethod (e.Thread, m, null);
1843 // Check that the stack frames remain valid during the invoke
1844 Assert.AreEqual ("Tests", (frame.GetThis () as ObjectMirror).Type.Name);
1846 // do another invoke
1847 m = t.GetMethod ("invoke_return_void");
1848 v = this_obj.InvokeMethod (e.Thread, m, null);
1851 // Try a single step after the invoke
1852 var req = vm.CreateStepRequest (e.Thread);
1853 req.Depth = StepDepth.Into;
1854 req.Size = StepSize.Line;
1859 // Step into invoke2
1861 e = vm.GetNextEvent ();
1862 Assert.IsTrue (e is StepEvent);
1863 Assert.AreEqual ("invoke2", (e as StepEvent).Method.Name);
1867 frame = e.Thread.GetFrames () [0];
1871 public void Exceptions () {
1872 Event e = run_until ("exceptions");
1873 var req = vm.CreateExceptionRequest (null);
1878 e = vm.GetNextEvent ();
1879 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
1880 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
1882 var frames = e.Thread.GetFrames ();
1883 Assert.AreEqual ("exceptions", frames [0].Method.Name);
1886 // exception type filter
1888 req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.ArgumentException", false, false));
1891 // Skip the throwing of the second OverflowException
1894 e = vm.GetNextEvent ();
1895 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
1896 Assert.AreEqual ("ArgumentException", (e as ExceptionEvent).Exception.Type.Name);
1899 // Implicit exceptions
1900 req = vm.CreateExceptionRequest (null);
1905 e = vm.GetNextEvent ();
1906 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
1907 Assert.AreEqual ("NullReferenceException", (e as ExceptionEvent).Exception.Type.Name);
1910 // Argument checking
1911 AssertThrows<ArgumentException> (delegate {
1912 vm.CreateExceptionRequest (e.Thread.Type);
1918 public void Domains () {
1921 Start (new string [] { "dtest-app.exe", "domain-test" });
1923 vm.EnableEvents (EventType.AppDomainCreate, EventType.AppDomainUnload);
1925 Event e = run_until ("domains");
1929 e = vm.GetNextEvent ();
1930 Assert.IsInstanceOfType (typeof (AppDomainCreateEvent), e);
1932 var domain = (e as AppDomainCreateEvent).Domain;
1934 // Run until the callback in the domain
1935 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke_in_domain");
1936 Assert.IsNotNull (m);
1937 vm.SetBreakpoint (m, 0);
1941 e = vm.GetNextEvent ();
1942 if (e is BreakpointEvent)
1946 Assert.AreEqual ("invoke_in_domain", (e as BreakpointEvent).Method.Name);
1948 // d_method is from another domain
1949 MethodMirror d_method = (e as BreakpointEvent).Method;
1950 Assert.IsTrue (m != d_method);
1952 var frames = e.Thread.GetFrames ();
1953 Assert.AreEqual ("invoke_in_domain", frames [0].Method.Name);
1954 Assert.AreEqual ("invoke", frames [1].Method.Name);
1955 Assert.AreEqual ("domains", frames [2].Method.Name);
1957 // This is empty when receiving the AppDomainCreateEvent
1958 Assert.AreEqual ("domain", domain.FriendlyName);
1960 // Run until the unload
1963 e = vm.GetNextEvent ();
1964 Assert.IsInstanceOfType (typeof (AppDomainUnloadEvent), e);
1965 Assert.AreEqual (domain, (e as AppDomainUnloadEvent).Domain);
1967 // Run past the unload
1968 e = run_until ("domains_2");
1970 // Test access to unloaded types
1971 // FIXME: Add an exception type for this
1972 AssertThrows<Exception> (delegate {
1973 d_method.DeclaringType.GetValue (d_method.DeclaringType.GetField ("static_i"));
1978 public void DynamicMethods () {
1979 Event e = run_until ("dyn_call");
1981 var m = e.Thread.GetFrames ()[1].Method;
1982 Assert.AreEqual ("dyn_method", m.Name);
1984 // Test access to IL
1985 var body = m.GetMethodBody ();
1987 ILInstruction ins = body.Instructions [0];
1988 Assert.AreEqual (OpCodes.Ldstr, ins.OpCode);
1989 Assert.AreEqual ("FOO", ins.Operand);
1993 public void RefEmit () {
1996 Start (new string [] { "dtest-app.exe", "ref-emit-test" });
1998 Event e = run_until ("ref_emit_call");
2000 var m = e.Thread.GetFrames ()[1].Method;
2001 Assert.AreEqual ("ref_emit_method", m.Name);
2003 // Test access to IL
2004 var body = m.GetMethodBody ();
2008 ins = body.Instructions [0];
2009 Assert.AreEqual (OpCodes.Ldstr, ins.OpCode);
2010 Assert.AreEqual ("FOO", ins.Operand);
2012 ins = body.Instructions [1];
2013 Assert.AreEqual (OpCodes.Call, ins.OpCode);
2014 Assert.IsInstanceOfType (typeof (MethodMirror), ins.Operand);
2015 Assert.AreEqual ("ref_emit_call", (ins.Operand as MethodMirror).Name);
2019 public void IsAttached () {
2020 var f = entry_point.DeclaringType.GetField ("is_attached");
2022 Event e = run_until ("Main");
2024 AssertValue (true, entry_point.DeclaringType.GetValue (f));