2 using System.Collections.Generic;
3 using System.Threading;
5 using System.Reflection;
8 using Mono.Debugger.Soft;
9 using Diag = System.Diagnostics;
12 using System.Security.Cryptography;
14 using NUnit.Framework;
16 #pragma warning disable 0219
22 public class DebuggerTests
25 MethodMirror entry_point;
26 StepEventRequest step_req;
29 void AssertThrows<ExType> (Action del) where ExType : Exception {
37 Assert.IsTrue (thrown);
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");
45 Event GetNextEvent () {
46 var es = vm.GetNextEventSet ();
47 Assert.AreEqual (1, es.Events.Length);
51 void Start (params string[] args) {
55 void Start (bool forceExit, params string[] args) {
56 this.forceExit = forceExit;
59 var pi = new Diag.ProcessStartInfo ();
62 pi.FileName = runtime;
65 pi.Arguments = String.Join (" ", args);
66 vm = VirtualMachineManager.Launch (pi, new LaunchOptions { AgentArgs = agent_args });
68 var ep = new IPEndPoint (IPAddress.Any, 10000);
69 Console.WriteLine ("Listening on " + ep + "...");
70 vm = VirtualMachineManager.Listen (ep);
73 var load_req = vm.CreateAssemblyLoadRequest ();
76 Event vmstart = GetNextEvent ();
77 Assert.AreEqual (EventType.VMStart, vmstart.EventType);
86 /* Find out the entry point */
90 if (e is AssemblyLoadEvent) {
91 AssemblyLoadEvent ae = (AssemblyLoadEvent)e;
92 entry_point = ae.Assembly.EntryPoint;
93 if (entry_point != null)
103 BreakpointEvent run_until (string name) {
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]);
115 if (e is BreakpointEvent)
121 Assert.IsInstanceOfType (typeof (BreakpointEvent), e);
122 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
124 return (e as BreakpointEvent);
127 Event single_step (ThreadMirror t) {
128 var req = vm.CreateStepRequest (t);
132 Event e = GetNextEvent ();
133 Assert.IsTrue (e is StepEvent);
140 Event step_until (ThreadMirror t, string method_name) {
144 if ((e as StepEvent).Method.Name == method_name)
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 ());
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);
160 Assert.AreEqual (eval, v);
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]);
170 Assert.IsTrue (val is PrimitiveValue);
171 Assert.AreEqual (expected, (val as PrimitiveValue).Value);
176 public void SetUp () {
177 ThreadMirror.NativeTransitions = false;
178 Start (new string [] { "dtest-app.exe" });
182 public void TearDown () {
186 if (step_req != null)
194 Event e = GetNextEvent ();
196 if (e is VMDeathEvent)
205 public void SimpleBreakpoint () {
208 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp1");
209 Assert.IsNotNull (m);
211 vm.SetBreakpoint (m, 0);
216 Assert.AreEqual (EventType.Breakpoint, e.EventType);
217 Assert.IsTrue (e is BreakpointEvent);
218 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
221 AssertThrows<ArgumentException> (delegate {
223 vm.SetBreakpoint (m, 2);
228 public void BreakpointsSameLocation () {
229 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp2");
230 Assert.IsNotNull (m);
232 vm.SetBreakpoint (m, 0);
233 vm.SetBreakpoint (m, 0);
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);
242 Assert.IsTrue (es [1] is BreakpointEvent);
243 Assert.AreEqual (m.Name, (es [1] as BreakpointEvent).Method.Name);
247 public void BreakpointAlreadyJITted () {
248 Event e = run_until ("bp1");
250 /* Place a breakpoint on bp3 */
251 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp3");
252 Assert.IsNotNull (m);
253 vm.SetBreakpoint (m, 0);
255 /* Same with generic instances */
256 MethodMirror m2 = entry_point.DeclaringType.GetMethod ("bp7");
257 Assert.IsNotNull (m2);
258 vm.SetBreakpoint (m2, 0);
263 Assert.AreEqual (EventType.Breakpoint, e.EventType);
264 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
268 /* Non-shared instance */
270 Assert.AreEqual (EventType.Breakpoint, e.EventType);
271 Assert.AreEqual (m2.Name, (e as BreakpointEvent).Method.Name);
275 /* Shared instance */
277 Assert.AreEqual (EventType.Breakpoint, e.EventType);
278 Assert.AreEqual (m2.Name, (e as BreakpointEvent).Method.Name);
282 public void ClearBreakpoint () {
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);
290 MethodMirror m2 = entry_point.DeclaringType.GetMethod ("bp5");
291 Assert.IsNotNull (m2);
292 vm.SetBreakpoint (m2, 0);
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);
304 /* Clear one of them */
310 Assert.AreEqual (EventType.Breakpoint, e.EventType);
311 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
313 /* Clear the other */
319 Assert.AreEqual (EventType.Breakpoint, e.EventType);
320 Assert.AreEqual (m2.Name, (e as BreakpointEvent).Method.Name);
324 public void ClearAllBreakpoints () {
327 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp4");
328 Assert.IsNotNull (m);
329 vm.SetBreakpoint (m, 0);
331 MethodMirror m2 = entry_point.DeclaringType.GetMethod ("bp5");
332 Assert.IsNotNull (m2);
333 vm.SetBreakpoint (m2, 0);
335 vm.ClearAllBreakpoints ();
340 Assert.IsTrue (!(e is BreakpointEvent));
341 if (e is VMDeathEvent)
346 public void BreakpointOnGShared () {
349 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp6");
350 Assert.IsNotNull (m);
352 vm.SetBreakpoint (m, 0);
357 Assert.AreEqual (EventType.Breakpoint, e.EventType);
358 Assert.IsTrue (e is BreakpointEvent);
359 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
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);
370 Assert.AreEqual (EventType.Breakpoint, e.EventType);
371 Assert.IsTrue (e is BreakpointEvent);
372 Assert.AreEqual (m2.Name, (e as BreakpointEvent).Method.Name);
375 void assert_location (Event e, string method) {
376 Assert.IsTrue (e is StepEvent);
377 Assert.AreEqual (method, (e as StepEvent).Method.Name);
380 StepEventRequest create_step (Event e) {
381 var req = vm.CreateStepRequest (e.Thread);
387 public void ClassLocalReflection () {
388 MethodMirror m = entry_point.DeclaringType.Assembly.GetType ("LocalReflectClass").GetMethod ("RunMe");
390 Assert.IsNotNull (m);
391 //Console.WriteLine ("X: " + name + " " + m.ILOffsets.Count + " " + m.Locations.Count);
393 int method_base_linum = m.Locations [0].LineNumber;
394 foreach (var location in m.Locations)
395 if (location.LineNumber == method_base_linum + 2) {
396 offset = location.ILOffset;
400 var req = vm.SetBreakpoint (m, offset);
407 if (e is BreakpointEvent)
413 Assert.IsInstanceOfType (typeof (BreakpointEvent), e);
414 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
416 e = single_step (e.Thread);
418 var frame = e.Thread.GetFrames ()[0];
419 Value variable = frame.GetValue (frame.Method.GetLocal ("reflectMe"));
421 ObjectMirror thisObj = (ObjectMirror)variable;
422 TypeMirror thisType = thisObj.Type;
423 FieldInfoMirror thisFi = null;
424 foreach (var fi in thisType.GetFields ())
425 if (fi.Name == "someField")
428 var gotVal = thisObj.GetValue (thisFi);
429 // If we got this far, we're good.
433 public void SingleStepping () {
434 Event e = run_until ("single_stepping");
436 var req = create_step (e);
439 // Step over 'bool b = true'
441 assert_location (e, "single_stepping");
448 assert_location (e, "ss1");
455 assert_location (e, "single_stepping");
459 assert_location (e, "single_stepping");
463 assert_location (e, "ss3");
465 // Step back into single_stepping
467 assert_location (e, "single_stepping");
469 // Step into next line
471 assert_location (e, "single_stepping");
473 // Step into ss3_2 ()
475 assert_location (e, "ss3_2");
477 // Step over ss3_2_2 ()
479 assert_location (e, "ss3_2");
481 // Recreate the request
488 // Step back into single_stepping () with the new request
490 assert_location (e, "single_stepping");
494 assert_location (e, "ss4");
499 // Change to StepSize.Line
501 req.Depth = StepDepth.Over;
502 req.Size = StepSize.Line;
505 // Step over ss1 (); ss1 ();
510 req.Depth = StepDepth.Into;
514 assert_location (e, "ss2");
519 e = run_until ("ss5");
521 // Add an assembly filter
522 req.AssemblyFilter = new AssemblyMirror [] { (e as BreakpointEvent).Method.DeclaringType.Assembly };
528 // Step into is_even, skipping the linq stuff
530 assert_location (e, "is_even");
532 // FIXME: Check that single stepping works with lock (obj)
536 e = run_until ("ss6");
538 req = create_step (e);
539 req.Depth = StepDepth.Over;
542 // Check that single stepping works in out-of-line bblocks
545 assert_location (e, "ss6");
548 // Check that a step over stops at an EH clause
549 e = run_until ("ss7_2");
550 req = create_step (e);
551 req.Depth = StepDepth.Out;
554 assert_location (e, "ss7");
556 req = create_step (e);
557 req.Depth = StepDepth.Over;
560 assert_location (e, "ss7");
563 // Check that stepping stops between nested calls
564 e = run_until ("ss_nested_2");
566 assert_location (e, "ss_nested");
568 assert_location (e, "ss_nested_1");
570 assert_location (e, "ss_nested");
571 // Check that step over steps over nested calls
573 assert_location (e, "ss_nested");
575 assert_location (e, "ss_nested_1");
577 assert_location (e, "ss_nested_1");
579 assert_location (e, "ss_nested");
582 // Check DebuggerStepThrough support
583 e = run_until ("ss_step_through");
584 req = create_step (e);
585 req.Filter = StepFilter.DebuggerStepThrough;
587 // Step through step_through_1 ()
589 assert_location (e, "ss_step_through");
590 // Step through StepThroughClass.step_through_2 ()
592 assert_location (e, "ss_step_through");
594 req.Filter = StepFilter.None;
596 assert_location (e, "step_through_3");
599 // Check DebuggerNonUserCode support
600 e = run_until ("ss_non_user_code");
601 req = create_step (e);
602 req.Filter = StepFilter.DebuggerNonUserCode;
604 // Step through non_user_code_1 ()
606 assert_location (e, "ss_non_user_code");
607 // Step through StepThroughClass.non_user_code_2 ()
609 assert_location (e, "ss_non_user_code");
611 req.Filter = StepFilter.None;
613 assert_location (e, "non_user_code_3");
616 // Check that step-over doesn't stop at inner frames with recursive functions
617 e = run_until ("ss_recursive");
618 req = create_step (e);
622 var f = e.Thread.GetFrames () [0];
623 assert_location (e, "ss_recursive");
624 AssertValue (1, f.GetValue (f.Method.GetLocal ("n")));
627 // Check that single stepping doesn't clobber fp values
628 e = run_until ("ss_fp_clobber");
629 req = create_step (e);
631 f = e.Thread.GetFrames ()[0];
633 if ((e as StepEvent).Method.Name == "ss_fp_clobber_2")
637 f = e.Thread.GetFrames ()[0];
638 AssertValue (7.0, f.GetValue (f.Method.GetParameters ()[0]));
643 public void MethodEntryExit () {
644 run_until ("single_stepping");
646 var req1 = vm.CreateMethodEntryRequest ();
647 var req2 = vm.CreateMethodExitRequest ();
653 Event e = GetNextEvent ();
654 Assert.IsTrue (e is MethodEntryEvent);
655 Assert.AreEqual ("ss1", (e as MethodEntryEvent).Method.Name);
659 Assert.IsTrue (e is MethodExitEvent);
660 Assert.AreEqual ("ss1", (e as MethodExitEvent).Method.Name);
667 public void CountFilter () {
668 run_until ("single_stepping");
670 MethodMirror m2 = entry_point.DeclaringType.GetMethod ("ss3");
671 Assert.IsNotNull (m2);
672 vm.SetBreakpoint (m2, 0);
674 var req1 = vm.CreateMethodEntryRequest ();
678 // Enter ss2, ss1 is skipped
680 Event e = GetNextEvent ();
681 Assert.IsTrue (e is MethodEntryEvent);
682 Assert.AreEqual ("ss2", (e as MethodEntryEvent).Method.Name);
684 // Breakpoint on ss3, the entry event is no longer reported
687 Assert.IsTrue (e is BreakpointEvent);
693 public void Arguments () {
696 var e = run_until ("arg1");
698 StackFrame frame = e.Thread.GetFrames () [0];
700 check_arg_val (frame, 0, typeof (sbyte), SByte.MaxValue - 5);
701 check_arg_val (frame, 1, typeof (byte), Byte.MaxValue - 5);
702 check_arg_val (frame, 2, typeof (bool), true);
703 check_arg_val (frame, 3, typeof (short), Int16.MaxValue - 5);
704 check_arg_val (frame, 4, typeof (ushort), UInt16.MaxValue - 5);
705 check_arg_val (frame, 5, typeof (char), 'F');
706 check_arg_val (frame, 6, typeof (int), Int32.MaxValue - 5);
707 check_arg_val (frame, 7, typeof (uint), UInt32.MaxValue - 5);
708 check_arg_val (frame, 8, typeof (long), Int64.MaxValue - 5);
709 check_arg_val (frame, 9, typeof (ulong), UInt64.MaxValue - 5);
710 check_arg_val (frame, 10, typeof (float), 1.2345f);
711 check_arg_val (frame, 11, typeof (double), 6.78910);
713 e = run_until ("arg2");
715 frame = e.Thread.GetFrames () [0];
718 val = frame.GetArgument (0);
719 AssertValue ("FOO", val);
720 Assert.AreEqual ("String", (val as ObjectMirror).Type.Name);
723 val = frame.GetArgument (1);
724 AssertValue (null, val);
727 val = frame.GetArgument (2);
728 AssertValue ("BLA", val);
731 val = frame.GetArgument (3);
732 AssertValue (42, val);
735 val = frame.GetArgument (4);
736 Assert.IsTrue (val is ObjectMirror);
737 Assert.AreEqual ("GClass`1", (val as ObjectMirror).Type.Name);
740 val = frame.GetArgument (5);
741 Assert.IsTrue (val is ObjectMirror);
742 Assert.AreEqual ("Object", (val as ObjectMirror).Type.Name);
744 // this on static methods
745 val = frame.GetThis ();
746 AssertValue (null, val);
748 e = run_until ("arg3");
750 frame = e.Thread.GetFrames () [0];
753 val = frame.GetThis ();
754 Assert.IsTrue (val is ObjectMirror);
755 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
757 // objref in register
758 val = frame.GetArgument (0);
759 AssertValue ("BLA", val);
763 public void Arrays () {
766 var e = run_until ("o2");
768 StackFrame frame = e.Thread.GetFrames () [0];
771 val = frame.GetArgument (0);
772 Assert.IsTrue (val is ArrayMirror);
773 ArrayMirror arr = val as ArrayMirror;
774 Assert.AreEqual (2, arr.Length);
775 AssertValue ("BAR", arr [0]);
776 AssertValue ("BAZ", arr [1]);
778 var vals = arr.GetValues (0, 2);
779 Assert.AreEqual (2, vals.Count);
780 AssertValue ("BAR", vals [0]);
781 AssertValue ("BAZ", vals [1]);
783 arr [0] = vm.RootDomain.CreateString ("ABC");
784 AssertValue ("ABC", arr [0]);
786 arr [0] = vm.CreateValue (null);
787 AssertValue (null, arr [0]);
789 arr.SetValues (0, new Value [] { vm.RootDomain.CreateString ("D1"), vm.RootDomain.CreateString ("D2") });
790 AssertValue ("D1", arr [0]);
791 AssertValue ("D2", arr [1]);
794 val = frame.GetArgument (1);
795 Assert.IsTrue (val is ArrayMirror);
796 arr = val as ArrayMirror;
797 Assert.AreEqual (2, arr.Length);
798 AssertValue (42, arr [0]);
799 AssertValue (43, arr [1]);
802 AssertThrows<IndexOutOfRangeException> (delegate () {
806 AssertThrows<IndexOutOfRangeException> (delegate () {
807 val = arr [Int32.MinValue];
810 AssertThrows<IndexOutOfRangeException> (delegate () {
811 vals = arr.GetValues (0, 3);
814 AssertThrows<IndexOutOfRangeException> (delegate () {
815 arr [2] = vm.CreateValue (null);
818 AssertThrows<IndexOutOfRangeException> (delegate () {
819 arr [Int32.MinValue] = vm.CreateValue (null);
822 AssertThrows<IndexOutOfRangeException> (delegate () {
823 arr.SetValues (0, new Value [] { null, null, null });
827 val = frame.GetArgument (2);
828 Assert.IsTrue (val is ArrayMirror);
829 arr = val as ArrayMirror;
830 Assert.AreEqual (2, arr.Rank);
831 Assert.AreEqual (4, arr.Length);
832 Assert.AreEqual (2, arr.GetLength (0));
833 Assert.AreEqual (2, arr.GetLength (1));
834 Assert.AreEqual (0, arr.GetLowerBound (0));
835 Assert.AreEqual (0, arr.GetLowerBound (1));
836 vals = arr.GetValues (0, 4);
837 AssertValue (1, vals [0]);
838 AssertValue (2, vals [1]);
839 AssertValue (3, vals [2]);
840 AssertValue (4, vals [3]);
842 val = frame.GetArgument (3);
843 Assert.IsTrue (val is ArrayMirror);
844 arr = val as ArrayMirror;
845 Assert.AreEqual (2, arr.Rank);
846 Assert.AreEqual (4, arr.Length);
847 Assert.AreEqual (2, arr.GetLength (0));
848 Assert.AreEqual (2, arr.GetLength (1));
849 Assert.AreEqual (1, arr.GetLowerBound (0));
850 Assert.AreEqual (3, arr.GetLowerBound (1));
852 AssertThrows<ArgumentOutOfRangeException> (delegate () {
855 AssertThrows<ArgumentOutOfRangeException> (delegate () {
859 AssertThrows<ArgumentOutOfRangeException> (delegate () {
860 arr.GetLowerBound (-1);
862 AssertThrows<ArgumentOutOfRangeException> (delegate () {
863 arr.GetLowerBound (2);
866 // arrays treated as generic collections
867 val = frame.GetArgument (4);
868 Assert.IsTrue (val is ArrayMirror);
869 arr = val as ArrayMirror;
873 public void Object_GetValue () {
874 var e = run_until ("o1");
875 var frame = e.Thread.GetFrames () [0];
877 object val = frame.GetThis ();
878 Assert.IsTrue (val is ObjectMirror);
879 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
880 ObjectMirror o = (val as ObjectMirror);
882 TypeMirror t = o.Type;
885 object f = o.GetValue (t.GetField ("field_i"));
887 f = o.GetValue (t.GetField ("field_s"));
888 AssertValue ("S", f);
889 f = o.GetValue (t.GetField ("field_enum"));
890 Assert.IsTrue (f is EnumMirror);
891 Assert.AreEqual (1, (f as EnumMirror).Value);
892 Assert.AreEqual ("B", (f as EnumMirror).StringValue);
894 // Inherited object fields
895 TypeMirror parent = t.BaseType;
896 f = o.GetValue (parent.GetField ("base_field_i"));
898 f = o.GetValue (parent.GetField ("base_field_s"));
899 AssertValue ("T", f);
902 f = o.GetValue (o.Type.GetField ("static_i"));
906 ObjectMirror o2 = frame.GetValue (frame.Method.GetParameters ()[1]) as ObjectMirror;
907 Assert.AreEqual ("GClass`1", o2.Type.Name);
908 TypeMirror t2 = o2.Type;
909 f = o2.GetValue (t2.GetField ("field"));
912 ObjectMirror o3 = frame.GetValue (frame.Method.GetParameters ()[2]) as ObjectMirror;
913 Assert.AreEqual ("GClass`1", o3.Type.Name);
914 TypeMirror t3 = o3.Type;
915 f = o3.GetValue (t3.GetField ("field"));
916 AssertValue ("FOO", f);
919 AssertThrows<ArgumentNullException> (delegate () {
925 public void Object_GetValues () {
926 var e = run_until ("o1");
927 var frame = e.Thread.GetFrames () [0];
929 object val = frame.GetThis ();
930 Assert.IsTrue (val is ObjectMirror);
931 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
932 ObjectMirror o = (val as ObjectMirror);
934 ObjectMirror val2 = frame.GetValue (frame.Method.GetParameters ()[0]) as ObjectMirror;
936 TypeMirror t = o.Type;
938 object[] vals = o.GetValues (new FieldInfoMirror [] { t.GetField ("field_i"), t.GetField ("field_s") });
942 AssertValue ("S", f);
945 AssertThrows<ArgumentNullException> (delegate () {
949 AssertThrows<ArgumentNullException> (delegate () {
950 o.GetValues (new FieldInfoMirror [] { null });
953 // field of another class
954 AssertThrows<ArgumentException> (delegate () {
955 o.GetValue (val2.Type.GetField ("field_j"));
959 void TestSetValue (ObjectMirror o, string field_name, object val) {
961 o.SetValue (o.Type.GetField (field_name), vm.RootDomain.CreateString ((string)val));
963 o.SetValue (o.Type.GetField (field_name), vm.CreateValue (val));
964 Value f = o.GetValue (o.Type.GetField (field_name));
965 AssertValue (val, f);
969 public void Object_SetValues () {
970 var e = run_until ("o1");
971 var frame = e.Thread.GetFrames () [0];
973 object val = frame.GetThis ();
974 Assert.IsTrue (val is ObjectMirror);
975 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
976 ObjectMirror o = (val as ObjectMirror);
978 ObjectMirror val2 = frame.GetValue (frame.Method.GetParameters ()[0]) as ObjectMirror;
980 TestSetValue (o, "field_i", 22);
981 TestSetValue (o, "field_bool1", false);
982 TestSetValue (o, "field_bool2", true);
983 TestSetValue (o, "field_char", 'B');
984 TestSetValue (o, "field_byte", (byte)129);
985 TestSetValue (o, "field_sbyte", (sbyte)-33);
986 TestSetValue (o, "field_short", (short)(Int16.MaxValue - 5));
987 TestSetValue (o, "field_ushort", (ushort)(UInt16.MaxValue - 5));
988 TestSetValue (o, "field_long", Int64.MaxValue - 5);
989 TestSetValue (o, "field_ulong", (ulong)(UInt64.MaxValue - 5));
990 TestSetValue (o, "field_float", 6.28f);
991 TestSetValue (o, "field_double", 6.28);
992 TestSetValue (o, "static_i", 23);
993 TestSetValue (o, "field_s", "CDEF");
998 f = o.GetValue (o.Type.GetField ("field_intptr"));
999 Assert.IsInstanceOfType (typeof (StructMirror), f);
1000 AssertValue (Int32.MaxValue - 5, (f as StructMirror).Fields [0]);
1003 FieldInfoMirror field = o.Type.GetField ("field_enum");
1004 f = o.GetValue (field);
1005 (f as EnumMirror).Value = 5;
1006 o.SetValue (field, f);
1007 f = o.GetValue (field);
1008 Assert.AreEqual (5, (f as EnumMirror).Value);
1011 o.SetValue (o.Type.GetField ("field_s"), vm.CreateValue (null));
1012 f = o.GetValue (o.Type.GetField ("field_s"));
1013 AssertValue (null, f);
1016 field = o.Type.GetField ("generic_field_struct");
1017 f = o.GetValue (field);
1018 o.SetValue (field, f);
1021 field = o.Type.GetField ("field_nullable");
1022 f = o.GetValue (field);
1023 AssertValue (0, (f as StructMirror).Fields [0]);
1024 AssertValue (false, (f as StructMirror).Fields [1]);
1025 o.SetValue (field, vm.CreateValue (6));
1026 f = o.GetValue (field);
1027 AssertValue (6, (f as StructMirror).Fields [0]);
1028 AssertValue (true, (f as StructMirror).Fields [1]);
1029 o.SetValue (field, vm.CreateValue (null));
1030 f = o.GetValue (field);
1031 AssertValue (0, (f as StructMirror).Fields [0]);
1032 AssertValue (false, (f as StructMirror).Fields [1]);
1034 // Argument checking
1035 AssertThrows<ArgumentNullException> (delegate () {
1036 o.SetValues (null, new Value [0]);
1039 AssertThrows<ArgumentNullException> (delegate () {
1040 o.SetValues (new FieldInfoMirror [0], null);
1043 AssertThrows<ArgumentNullException> (delegate () {
1044 o.SetValues (new FieldInfoMirror [] { null }, new Value [1] { null });
1047 // vtype with a wrong type
1048 AssertThrows<ArgumentException> (delegate () {
1049 o.SetValue (o.Type.GetField ("field_struct"), o.GetValue (o.Type.GetField ("field_enum")));
1052 // reference type not assignment compatible
1053 AssertThrows<ArgumentException> (delegate () {
1054 o.SetValue (o.Type.GetField ("field_class"), o);
1057 // field of another class
1058 AssertThrows<ArgumentException> (delegate () {
1059 o.SetValue (val2.Type.GetField ("field_j"), vm.CreateValue (1));
1064 public void Type_SetValue () {
1065 var e = run_until ("o1");
1066 var frame = e.Thread.GetFrames () [0];
1069 object val = frame.GetThis ();
1070 Assert.IsTrue (val is ObjectMirror);
1071 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
1072 ObjectMirror o = (val as ObjectMirror);
1074 ObjectMirror val2 = frame.GetValue (frame.Method.GetParameters ()[0]) as ObjectMirror;
1076 o.Type.SetValue (o.Type.GetField ("static_i"), vm.CreateValue (55));
1077 f = o.Type.GetValue (o.Type.GetField ("static_i"));
1078 AssertValue (55, f);
1080 o.Type.SetValue (o.Type.GetField ("static_s"), vm.RootDomain.CreateString ("B"));
1081 f = o.Type.GetValue (o.Type.GetField ("static_s"));
1082 AssertValue ("B", f);
1084 // Argument checking
1085 AssertThrows<ArgumentNullException> (delegate () {
1086 o.Type.SetValue (null, vm.CreateValue (0));
1089 AssertThrows<ArgumentNullException> (delegate () {
1090 o.Type.SetValue (o.Type.GetField ("static_i"), null);
1093 // field of another class
1094 AssertThrows<ArgumentException> (delegate () {
1095 o.SetValue (val2.Type.GetField ("field_j"), vm.CreateValue (1));
1100 public void TypeInfo () {
1101 Event e = run_until ("ti2");
1102 StackFrame frame = e.Thread.GetFrames () [0];
1107 t = frame.Method.GetParameters ()[0].ParameterType;
1109 Assert.AreEqual ("String[]", t.Name);
1110 Assert.AreEqual ("string[]", t.CSharpName);
1111 Assert.AreEqual ("Array", t.BaseType.Name);
1112 Assert.AreEqual (true, t.HasElementType);
1113 Assert.AreEqual (true, t.IsArray);
1114 Assert.AreEqual (1, t.GetArrayRank ());
1115 Assert.AreEqual ("String", t.GetElementType ().Name);
1117 t = frame.Method.GetParameters ()[2].ParameterType;
1119 Assert.AreEqual ("Int32[,]", t.Name);
1121 //Assert.AreEqual ("int[,]", t.CSharpName);
1122 Assert.AreEqual ("Array", t.BaseType.Name);
1123 Assert.AreEqual (true, t.HasElementType);
1124 Assert.AreEqual (true, t.IsArray);
1125 Assert.AreEqual (2, t.GetArrayRank ());
1126 Assert.AreEqual ("Int32", t.GetElementType ().Name);
1129 t = frame.Method.GetParameters ()[3].ParameterType;
1131 //Assert.AreEqual ("Int32&", t.Name);
1132 //Assert.AreEqual (true, t.IsByRef);
1133 //Assert.AreEqual (true, t.HasElementType);
1136 t = frame.Method.GetParameters ()[4].ParameterType;
1138 //Assert.AreEqual ("Int32*", t.Name);
1139 Assert.AreEqual (true, t.IsPointer);
1140 Assert.AreEqual (true, t.HasElementType);
1141 Assert.AreEqual ("Int32", t.GetElementType ().Name);
1142 Assert.AreEqual (false, t.IsPrimitive);
1145 t = frame.Method.GetParameters ()[5].ParameterType;
1146 Assert.AreEqual (true, t.IsPrimitive);
1149 t = frame.Method.GetParameters ()[6].ParameterType;
1150 Assert.AreEqual ("AStruct", t.Name);
1151 Assert.AreEqual (false, t.IsPrimitive);
1152 Assert.AreEqual (true, t.IsValueType);
1153 Assert.AreEqual (false, t.IsClass);
1156 t = frame.Method.GetParameters ()[7].ParameterType;
1157 Assert.AreEqual ("Tests", t.Name);
1158 var nested = (from nt in t.GetNestedTypes () where nt.IsNestedPublic select nt).ToArray ();
1159 Assert.AreEqual (1, nested.Length);
1160 Assert.AreEqual ("NestedClass", nested [0].Name);
1161 Assert.IsTrue (t.BaseType.IsAssignableFrom (t));
1162 Assert.IsTrue (!t.IsAssignableFrom (t.BaseType));
1164 // generic instances
1165 t = frame.Method.GetParameters ()[9].ParameterType;
1166 Assert.AreEqual ("GClass`1", t.Name);
1167 Assert.IsTrue (t.IsGenericType);
1168 Assert.IsFalse (t.IsGenericTypeDefinition);
1170 var args = t.GetGenericArguments ();
1171 Assert.AreEqual (1, args.Length);
1172 Assert.AreEqual ("Int32", args [0].Name);
1174 // generic type definitions
1175 var gtd = t.GetGenericTypeDefinition ();
1176 Assert.AreEqual ("GClass`1", gtd.Name);
1177 Assert.IsTrue (gtd.IsGenericType);
1178 Assert.IsTrue (gtd.IsGenericTypeDefinition);
1179 Assert.AreEqual (gtd, gtd.GetGenericTypeDefinition ());
1181 args = gtd.GetGenericArguments ();
1182 Assert.AreEqual (1, args.Length);
1183 Assert.AreEqual ("T", args [0].Name);
1186 t = frame.Method.GetParameters ()[10].ParameterType;
1187 Assert.AreEqual ("AnEnum", t.Name);
1188 Assert.IsTrue (t.IsEnum);
1189 Assert.AreEqual ("Int32", t.EnumUnderlyingType.Name);
1192 t = frame.Method.GetParameters ()[11].ParameterType;
1193 Assert.AreEqual ("TypedReference", t.Name);
1196 t = frame.Method.GetParameters ()[7].ParameterType;
1198 var props = t.GetProperties ();
1199 Assert.AreEqual (3, props.Length);
1200 foreach (PropertyInfoMirror prop in props) {
1201 ParameterInfoMirror[] indexes = prop.GetIndexParameters ();
1203 if (prop.Name == "IntProperty") {
1204 Assert.AreEqual ("Int32", prop.PropertyType.Name);
1205 Assert.AreEqual ("get_IntProperty", prop.GetGetMethod ().Name);
1206 Assert.AreEqual ("set_IntProperty", prop.GetSetMethod ().Name);
1207 Assert.AreEqual (0, indexes.Length);
1208 } else if (prop.Name == "ReadOnlyProperty") {
1209 Assert.AreEqual ("Int32", prop.PropertyType.Name);
1210 Assert.AreEqual ("get_ReadOnlyProperty", prop.GetGetMethod ().Name);
1211 Assert.AreEqual (null, prop.GetSetMethod ());
1212 Assert.AreEqual (0, indexes.Length);
1213 } else if (prop.Name == "IndexedProperty") {
1214 Assert.AreEqual (1, indexes.Length);
1215 Assert.AreEqual ("Int32", indexes [0].ParameterType.Name);
1219 // custom attributes
1220 t = frame.Method.GetParameters ()[8].ParameterType;
1221 Assert.AreEqual ("Tests2", t.Name);
1222 var attrs = t.GetCustomAttributes (true);
1223 Assert.AreEqual (5, attrs.Length);
1224 foreach (var attr in attrs) {
1225 if (attr.Constructor.DeclaringType.Name == "DebuggerDisplayAttribute") {
1226 Assert.AreEqual (1, attr.ConstructorArguments.Count);
1227 Assert.AreEqual ("Tests", attr.ConstructorArguments [0].Value);
1228 Assert.AreEqual (2, attr.NamedArguments.Count);
1229 Assert.AreEqual ("Name", attr.NamedArguments [0].Property.Name);
1230 Assert.AreEqual ("FOO", attr.NamedArguments [0].TypedValue.Value);
1231 Assert.AreEqual ("Target", attr.NamedArguments [1].Property.Name);
1232 Assert.IsInstanceOfType (typeof (TypeMirror), attr.NamedArguments [1].TypedValue.Value);
1233 Assert.AreEqual ("Int32", (attr.NamedArguments [1].TypedValue.Value as TypeMirror).Name);
1234 } else if (attr.Constructor.DeclaringType.Name == "DebuggerTypeProxyAttribute") {
1235 Assert.AreEqual (1, attr.ConstructorArguments.Count);
1236 Assert.IsInstanceOfType (typeof (TypeMirror), attr.ConstructorArguments [0].Value);
1237 Assert.AreEqual ("Tests", (attr.ConstructorArguments [0].Value as TypeMirror).Name);
1238 } else if (attr.Constructor.DeclaringType.Name == "BAttribute") {
1239 Assert.AreEqual (2, attr.NamedArguments.Count);
1240 Assert.AreEqual ("afield", attr.NamedArguments [0].Field.Name);
1241 Assert.AreEqual ("bfield", attr.NamedArguments [1].Field.Name);
1242 } else if (attr.Constructor.DeclaringType.Name == "ClassInterfaceAttribute") {
1243 // inherited from System.Object
1244 //} else if (attr.Constructor.DeclaringType.Name == "Serializable") {
1245 // inherited from System.Object
1246 } else if (attr.Constructor.DeclaringType.Name == "ComVisibleAttribute") {
1247 // inherited from System.Object
1249 Assert.Fail (attr.Constructor.DeclaringType.Name);
1253 var assembly = entry_point.DeclaringType.Assembly;
1254 var type = assembly.GetType ("Tests4");
1255 Assert.IsFalse (type.IsInitialized);
1259 public void FieldInfo () {
1260 Event e = run_until ("ti2");
1261 StackFrame frame = e.Thread.GetFrames () [0];
1265 t = frame.Method.GetParameters ()[8].ParameterType;
1266 Assert.AreEqual ("Tests2", t.Name);
1268 var fi = t.GetField ("field_j");
1269 var attrs = fi.GetCustomAttributes (true);
1270 Assert.AreEqual (1, attrs.Length);
1271 var attr = attrs [0];
1272 Assert.AreEqual ("DebuggerBrowsableAttribute", attr.Constructor.DeclaringType.Name);
1273 Assert.AreEqual (1, attr.ConstructorArguments.Count);
1274 Assert.IsInstanceOfType (typeof (EnumMirror), attr.ConstructorArguments [0].Value);
1275 Assert.AreEqual ((int)System.Diagnostics.DebuggerBrowsableState.Collapsed, (attr.ConstructorArguments [0].Value as EnumMirror).Value);
1279 public void PropertyInfo () {
1280 Event e = run_until ("ti2");
1281 StackFrame frame = e.Thread.GetFrames () [0];
1285 t = frame.Method.GetParameters ()[8].ParameterType;
1286 Assert.AreEqual ("Tests2", t.Name);
1288 var pi = t.GetProperty ("AProperty");
1289 var attrs = pi.GetCustomAttributes (true);
1290 Assert.AreEqual (1, attrs.Length);
1291 var attr = attrs [0];
1292 Assert.AreEqual ("DebuggerBrowsableAttribute", attr.Constructor.DeclaringType.Name);
1293 Assert.AreEqual (1, attr.ConstructorArguments.Count);
1294 Assert.IsInstanceOfType (typeof (EnumMirror), attr.ConstructorArguments [0].Value);
1295 Assert.AreEqual ((int)System.Diagnostics.DebuggerBrowsableState.Collapsed, (attr.ConstructorArguments [0].Value as EnumMirror).Value);
1299 [Category ("only5")]
1300 public void Type_GetValue () {
1301 Event e = run_until ("o1");
1302 StackFrame frame = e.Thread.GetFrames () [0];
1304 ObjectMirror o = (frame.GetThis () as ObjectMirror);
1306 TypeMirror t = o.Type;
1308 ObjectMirror val2 = frame.GetValue (frame.Method.GetParameters ()[0]) as ObjectMirror;
1311 object f = t.GetValue (o.Type.GetField ("static_i"));
1312 AssertValue (55, f);
1314 f = t.GetValue (o.Type.GetField ("static_s"));
1315 AssertValue ("A", f);
1317 // literal static fields
1318 f = t.GetValue (o.Type.GetField ("literal_i"));
1319 AssertValue (56, f);
1321 f = t.GetValue (o.Type.GetField ("literal_s"));
1322 AssertValue ("B", f);
1324 // Inherited static fields
1325 TypeMirror parent = t.BaseType;
1326 f = t.GetValue (parent.GetField ("base_static_i"));
1327 AssertValue (57, f);
1329 f = t.GetValue (parent.GetField ("base_static_s"));
1330 AssertValue ("C", f);
1332 // thread static field
1333 f = t.GetValue (t.GetField ("tls_i"), e.Thread);
1334 AssertValue (42, f);
1336 // Argument checking
1337 AssertThrows<ArgumentNullException> (delegate () {
1342 AssertThrows<ArgumentException> (delegate () {
1343 t.GetValue (o.Type.GetField ("field_i"));
1346 // field on another type
1347 AssertThrows<ArgumentException> (delegate () {
1348 t.GetValue (val2.Type.GetField ("static_field_j"));
1351 // special static field
1352 AssertThrows<ArgumentException> (delegate () {
1353 t.GetValue (t.GetField ("tls_i"));
1358 public void Type_GetValues () {
1359 Event e = run_until ("o1");
1360 StackFrame frame = e.Thread.GetFrames () [0];
1362 ObjectMirror o = (frame.GetThis () as ObjectMirror);
1364 TypeMirror t = o.Type;
1367 object[] vals = t.GetValues (new FieldInfoMirror [] { t.GetField ("static_i"), t.GetField ("static_s") });
1368 object f = vals [0];
1369 AssertValue (55, f);
1372 AssertValue ("A", f);
1374 // Argument checking
1375 AssertThrows<ArgumentNullException> (delegate () {
1379 AssertThrows<ArgumentNullException> (delegate () {
1380 t.GetValues (new FieldInfoMirror [] { null });
1385 public void ObjRefs () {
1386 Event e = run_until ("objrefs1");
1387 StackFrame frame = e.Thread.GetFrames () [0];
1389 ObjectMirror o = frame.GetThis () as ObjectMirror;
1390 ObjectMirror child = o.GetValue (o.Type.GetField ("child")) as ObjectMirror;
1392 Assert.IsTrue (child.Address != 0);
1394 // Check that object references are internalized correctly
1395 Assert.AreEqual (o, frame.GetThis ());
1397 run_until ("objrefs2");
1399 // child should be gc'd now
1400 // This is not deterministic
1401 //Assert.IsTrue (child.IsCollected);
1404 * No longer works since Type is read eagerly
1407 AssertThrows<ObjectCollectedException> (delegate () {
1408 TypeMirror t = child.Type;
1412 AssertThrows<ObjectCollectedException> (delegate () {
1413 long addr = child.Address;
1419 public void Type_GetObject () {
1420 Event e = run_until ("o1");
1421 StackFrame frame = e.Thread.GetFrames () [0];
1423 ObjectMirror o = (frame.GetThis () as ObjectMirror);
1425 TypeMirror t = o.Type;
1427 Assert.AreEqual ("MonoType", t.GetTypeObject ().Type.Name);
1431 public void VTypes () {
1432 Event e = run_until ("vtypes1");
1433 StackFrame frame = e.Thread.GetFrames () [0];
1436 ObjectMirror o = frame.GetThis () as ObjectMirror;
1437 var obj = o.GetValue (o.Type.GetField ("field_struct"));
1438 Assert.IsTrue (obj is StructMirror);
1439 var s = obj as StructMirror;
1440 Assert.AreEqual ("AStruct", s.Type.Name);
1441 AssertValue (42, s ["i"]);
1443 AssertValue ("S", obj);
1444 AssertValue (43, s ["k"]);
1445 obj = o.GetValue (o.Type.GetField ("field_boxed_struct"));
1446 Assert.IsTrue (obj is StructMirror);
1447 s = obj as StructMirror;
1448 Assert.AreEqual ("AStruct", s.Type.Name);
1449 AssertValue (42, s ["i"]);
1451 // Check decoding of nested structs (#14942)
1452 obj = o.GetValue (o.Type.GetField ("nested_struct"));
1453 o.SetValue (o.Type.GetField ("nested_struct"), obj);
1455 // Check round tripping of boxed struct fields (#12354)
1456 obj = o.GetValue (o.Type.GetField ("boxed_struct_field"));
1457 o.SetValue (o.Type.GetField ("boxed_struct_field"), obj);
1458 obj = o.GetValue (o.Type.GetField ("boxed_struct_field"));
1459 s = obj as StructMirror;
1460 AssertValue (1, s ["key"]);
1462 Assert.IsTrue (obj is StructMirror);
1463 s = obj as StructMirror;
1464 AssertValue (42, s ["m_value"]);
1466 // vtypes as arguments
1467 s = frame.GetArgument (0) as StructMirror;
1468 AssertValue (44, s ["i"]);
1470 AssertValue ("T", obj);
1471 AssertValue (45, s ["k"]);
1473 // vtypes as array entries
1474 var arr = frame.GetArgument (1) as ArrayMirror;
1476 Assert.IsTrue (obj is StructMirror);
1477 s = obj as StructMirror;
1478 AssertValue (1, s ["i"]);
1479 AssertValue ("S1", s ["s"]);
1481 Assert.IsTrue (obj is StructMirror);
1482 s = obj as StructMirror;
1483 AssertValue (2, s ["i"]);
1484 AssertValue ("S2", s ["s"]);
1487 var typedref = frame.GetArgument (2) as StructMirror;
1488 Assert.IsTrue (typedref is StructMirror);
1490 // Argument checking
1491 s = frame.GetArgument (0) as StructMirror;
1492 AssertThrows<ArgumentException> (delegate () {
1496 // generic vtype instances
1497 o = frame.GetThis () as ObjectMirror;
1498 obj = o.GetValue (o.Type.GetField ("generic_field_struct"));
1499 Assert.IsTrue (obj is StructMirror);
1500 s = obj as StructMirror;
1501 Assert.AreEqual ("GStruct`1", s.Type.Name);
1502 AssertValue (42, s ["i"]);
1504 // this on vtype methods
1505 e = run_until ("vtypes2");
1506 e = step_until (e.Thread, "foo");
1508 frame = e.Thread.GetFrames () [0];
1510 Assert.AreEqual ("foo", (e as StepEvent).Method.Name);
1511 obj = frame.GetThis ();
1513 Assert.IsTrue (obj is StructMirror);
1514 s = obj as StructMirror;
1515 AssertValue (44, s ["i"]);
1516 AssertValue ("T", s ["s"]);
1517 AssertValue (45, s ["k"]);
1519 // this on static vtype methods
1520 e = run_until ("vtypes3");
1521 e = step_until (e.Thread, "static_foo");
1523 frame = e.Thread.GetFrames () [0];
1525 Assert.AreEqual ("static_foo", (e as StepEvent).Method.Name);
1526 obj = frame.GetThis ();
1527 AssertValue (null, obj);
1529 // vtypes which reference themselves recursively
1530 e = run_until ("vtypes4_2");
1531 frame = e.Thread.GetFrames () [0];
1533 Assert.IsTrue (frame.GetArgument (0) is StructMirror);
1537 public void AssemblyInfo () {
1538 Event e = run_until ("single_stepping");
1540 StackFrame frame = e.Thread.GetFrames () [0];
1542 var aname = frame.Method.DeclaringType.Assembly.GetName ();
1543 Assert.AreEqual ("dtest-app, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", aname.ToString ());
1545 ModuleMirror m = frame.Method.DeclaringType.Module;
1547 Assert.AreEqual ("dtest-app.exe", m.Name);
1548 Assert.AreEqual ("dtest-app.exe", m.ScopeName);
1549 Assert.IsTrue (m.FullyQualifiedName.IndexOf ("dtest-app.exe") != -1);
1550 Guid guid = m.ModuleVersionId;
1551 Assert.AreEqual (frame.Method.DeclaringType.Assembly, m.Assembly);
1552 Assert.AreEqual (frame.Method.DeclaringType.Assembly.ManifestModule, m);
1554 // This is no longer true on 4.0
1555 //Assert.AreEqual ("Assembly", frame.Method.DeclaringType.Assembly.GetAssemblyObject ().Type.Name);
1557 TypeMirror t = vm.RootDomain.Corlib.GetType ("System.Diagnostics.DebuggerDisplayAttribute");
1558 Assert.AreEqual ("DebuggerDisplayAttribute", t.Name);
1562 public void LocalsInfo () {
1563 Event e = run_until ("locals2");
1565 StackFrame frame = e.Thread.GetFrames () [0];
1567 var locals = frame.Method.GetLocals ();
1568 Assert.AreEqual (9, locals.Length);
1569 for (int i = 0; i < 9; ++i) {
1570 if (locals [i].Name == "args") {
1571 Assert.IsTrue (locals [i].IsArg);
1572 Assert.AreEqual ("String[]", locals [i].Type.Name);
1573 } else if (locals [i].Name == "arg") {
1574 Assert.IsTrue (locals [i].IsArg);
1575 Assert.AreEqual ("Int32", locals [i].Type.Name);
1576 } else if (locals [i].Name == "i") {
1577 Assert.IsFalse (locals [i].IsArg);
1578 Assert.AreEqual ("Int64", locals [i].Type.Name);
1579 } else if (locals [i].Name == "j") {
1580 Assert.IsFalse (locals [i].IsArg);
1581 Assert.AreEqual ("Int32", locals [i].Type.Name);
1582 } else if (locals [i].Name == "s") {
1583 Assert.IsFalse (locals [i].IsArg);
1584 Assert.AreEqual ("String", locals [i].Type.Name);
1585 } else if (locals [i].Name == "t") {
1587 Assert.IsTrue (locals [i].IsArg);
1588 Assert.AreEqual ("String", locals [i].Type.Name);
1589 } else if (locals [i].Name == "rs") {
1590 Assert.IsTrue (locals [i].IsArg);
1591 Assert.AreEqual ("String", locals [i].Type.Name);
1592 } else if (locals [i].Name == "astruct") {
1593 } else if (locals [i].Name == "alist") {
1600 Event step_once () {
1602 var e = GetNextEvent ();
1603 Assert.IsTrue (e is StepEvent);
1607 Event step_into () {
1608 step_req.Disable ();
1609 step_req.Depth = StepDepth.Into;
1611 return step_once ();
1614 Event step_over () {
1615 step_req.Disable ();
1616 step_req.Depth = StepDepth.Over;
1618 return step_once ();
1622 step_req.Disable ();
1623 step_req.Depth = StepDepth.Out;
1625 return step_once ();
1629 public void Locals () {
1630 var be = run_until ("locals1");
1632 StackFrame frame = be.Thread.GetFrames () [0];
1633 MethodMirror m1 = frame.Method;
1635 // Compiler generated byref local
1636 foreach (var l in m1.GetLocals ()) {
1637 // The byval flag is hidden from the type
1638 if (l.Name != "ri" && l.Type.Name == "Double")
1639 AssertValue (null, frame.GetValue (l));
1642 be = run_until ("locals2");
1644 frame = be.Thread.GetFrames () [0];
1646 object val = frame.GetValue (frame.Method.GetLocal ("i"));
1647 AssertValue (0, val);
1649 var req = create_step (be);
1656 var e = step_once ();
1657 Assert.AreEqual ("locals2", (e as StepEvent).Method.Name);
1659 // Execute s = "AB";
1661 Assert.AreEqual ("locals2", (e as StepEvent).Method.Name);
1663 frame = e.Thread.GetFrames () [0];
1665 val = frame.GetValue (frame.Method.GetLocal ("i"));
1666 AssertValue (42, val);
1668 LocalVariable[] locals = frame.Method.GetLocals ();
1669 var vals = frame.GetValues (locals);
1670 Assert.AreEqual (locals.Length, vals.Length);
1671 for (int i = 0; i < locals.Length; ++i) {
1672 if (locals [i].Name == "i")
1673 AssertValue (42, vals [i]);
1674 if (locals [i].Name == "s")
1675 AssertValue ("AB", vals [i]);
1676 if (locals [i].Name == "t")
1677 AssertValue ("ABC", vals [i]);
1678 if (locals [i].Name == "alist") {
1682 // Argument checking
1685 AssertThrows<ArgumentNullException> (delegate () {
1686 frame.GetValue ((LocalVariable)null);
1688 // GetValue () local from another method
1689 AssertThrows<ArgumentException> (delegate () {
1690 frame.GetValue (m1.GetLocal ("foo"));
1694 AssertThrows<ArgumentNullException> (delegate () {
1695 frame.GetValue ((ParameterInfoMirror)null);
1697 // GetValue () local from another method
1698 AssertThrows<ArgumentException> (delegate () {
1699 frame.GetValue (m1.GetParameters ()[0]);
1702 // GetValues () null
1703 AssertThrows<ArgumentNullException> (delegate () {
1704 frame.GetValues (null);
1706 // GetValues () embedded null
1707 AssertThrows<ArgumentNullException> (delegate () {
1708 frame.GetValues (new LocalVariable [] { null });
1710 // GetValues () local from another method
1711 AssertThrows<ArgumentException> (delegate () {
1712 frame.GetValues (new LocalVariable [] { m1.GetLocal ("foo") });
1715 AssertThrows<ArgumentException> (delegate () {
1716 val = frame.GetValue (frame.Method.ReturnParameter);
1719 // invalid stack frames
1721 e = GetNextEvent ();
1722 Assert.IsTrue (e is StepEvent);
1723 Assert.AreEqual ("locals2", (e as StepEvent).Method.Name);
1725 AssertThrows<InvalidStackFrameException> (delegate () {
1726 frame.GetValue (frame.Method.GetLocal ("i"));
1732 be = run_until ("locals7");
1734 req = create_step (be);
1740 // Test that locals are initialized
1741 frame = e.Thread.GetFrames () [0];
1742 val = frame.GetValue (frame.Method.GetLocal ("t"));
1743 AssertValue (0, val);
1747 Assert.AreEqual ("locals7", (e as StepEvent).Method.Name);
1751 Assert.AreEqual ("locals7", (e as StepEvent).Method.Name);
1753 frame = e.Thread.GetFrames () [0];
1754 val = frame.GetValue (frame.Method.GetParameters ()[0]);
1755 AssertValue (22, val);
1756 val = frame.GetValue (frame.Method.GetLocal ("t"));
1757 AssertValue (22, val);
1758 val = frame.GetValue (frame.Method.GetLocal ("t2"));
1759 AssertValue (22, val);
1763 public void GetVisibleVariables () {
1764 Event e = run_until ("locals4");
1767 var locals = e.Thread.GetFrames ()[1].GetVisibleVariables ();
1768 Assert.AreEqual (2, locals.Count);
1769 var loc = locals.First (l => l.Name == "i");
1770 Assert.AreEqual ("Int64", loc.Type.Name);
1771 loc = locals.First (l => l.Name == "s");
1772 Assert.AreEqual ("String", loc.Type.Name);
1774 loc = e.Thread.GetFrames ()[1].GetVisibleVariableByName ("i");
1775 Assert.AreEqual ("i", loc.Name);
1776 Assert.AreEqual ("Int64", loc.Type.Name);
1778 e = run_until ("locals5");
1781 locals = e.Thread.GetFrames ()[1].GetVisibleVariables ();
1782 Assert.AreEqual (2, locals.Count);
1783 loc = locals.First (l => l.Name == "i");
1784 Assert.AreEqual ("String", loc.Type.Name);
1785 loc = locals.First (l => l.Name == "s");
1786 Assert.AreEqual ("String", loc.Type.Name);
1788 loc = e.Thread.GetFrames ()[1].GetVisibleVariableByName ("i");
1789 Assert.AreEqual ("i", loc.Name);
1790 Assert.AreEqual ("String", loc.Type.Name);
1792 // Variable in another scope
1793 loc = e.Thread.GetFrames ()[1].GetVisibleVariableByName ("j");
1794 Assert.IsNull (loc);
1798 public void Exit () {
1803 var e = GetNextEvent ();
1804 Assert.IsInstanceOfType (typeof (VMDeathEvent), e);
1806 Assert.AreEqual (5, (e as VMDeathEvent).ExitCode);
1809 /* Could be a remote vm with no process */
1812 Assert.AreEqual (5, p.ExitCode);
1815 AssertThrows<VMDisconnectedException> (delegate () {
1824 public void Dispose () {
1829 var e = GetNextEvent ();
1830 Assert.IsInstanceOfType (typeof (VMDisconnectEvent), e);
1833 /* Could be a remote vm with no process */
1836 Assert.AreEqual (3, p.ExitCode);
1839 AssertThrows<VMDisconnectedException> (delegate () {
1848 public void ColumnNumbers () {
1849 Event e = run_until ("line_numbers");
1851 // FIXME: Merge this with LineNumbers () when its fixed
1853 step_req = create_step (e);
1854 step_req.Depth = StepDepth.Into;
1862 e = GetNextEvent ();
1863 Assert.IsTrue (e is StepEvent);
1864 if (e.Thread.GetFrames ()[0].Method.Name == "ln1")
1868 // Do an additional step over so we are not on the beginning line of the method
1869 step_req.Disable ();
1870 step_req.Depth = StepDepth.Over;
1873 e = GetNextEvent ();
1874 Assert.IsTrue (e is StepEvent);
1876 l = e.Thread.GetFrames ()[0].Location;
1878 Assert.AreEqual (3, l.ColumnNumber);
1880 step_req.Disable ();
1884 // Broken by mcs+runtime changes (#5438)
1885 [Category("NotWorking")]
1886 public void LineNumbers () {
1887 Event e = run_until ("line_numbers");
1889 step_req = create_step (e);
1890 step_req.Depth = StepDepth.Into;
1897 e = GetNextEvent ();
1898 Assert.IsTrue (e is StepEvent);
1900 l = e.Thread.GetFrames ()[0].Location;
1902 Assert.IsTrue (l.SourceFile.IndexOf ("dtest-app.cs") != -1);
1903 Assert.AreEqual ("ln1", l.Method.Name);
1906 using (FileStream fs = new FileStream (l.SourceFile, FileMode.Open, FileAccess.Read)) {
1907 MD5 md5 = MD5.Create ();
1908 var hash = md5.ComputeHash (fs);
1910 for (int i = 0; i < 16; ++i)
1911 Assert.AreEqual (hash [i], l.SourceFileHash [i]);
1914 int line_base = l.LineNumber;
1917 e = GetNextEvent ();
1918 Assert.IsTrue (e is StepEvent);
1919 l = e.Thread.GetFrames ()[0].Location;
1920 Assert.AreEqual ("ln2", l.Method.Name);
1921 Assert.AreEqual (line_base + 6, l.LineNumber);
1924 e = GetNextEvent ();
1925 Assert.IsTrue (e is StepEvent);
1926 l = e.Thread.GetFrames ()[0].Location;
1927 Assert.AreEqual ("ln1", l.Method.Name);
1928 Assert.AreEqual (line_base + 1, l.LineNumber);
1931 e = GetNextEvent ();
1932 Assert.IsTrue (e is StepEvent);
1933 l = e.Thread.GetFrames ()[0].Location;
1934 Assert.AreEqual ("ln3", l.Method.Name);
1935 Assert.AreEqual (line_base + 11, l.LineNumber);
1938 e = GetNextEvent ();
1939 Assert.IsTrue (e is StepEvent);
1940 l = e.Thread.GetFrames ()[0].Location;
1941 Assert.AreEqual ("ln3", l.Method.Name);
1942 Assert.IsTrue (l.SourceFile.EndsWith ("FOO"));
1943 Assert.AreEqual (55, l.LineNumber);
1946 e = GetNextEvent ();
1947 Assert.IsTrue (e is StepEvent);
1948 l = e.Thread.GetFrames ()[0].Location;
1949 Assert.AreEqual ("ln1", l.Method.Name);
1950 Assert.AreEqual (line_base + 2, l.LineNumber);
1952 // GetSourceFiles ()
1953 string[] sources = l.Method.DeclaringType.GetSourceFiles ();
1954 Assert.AreEqual (2, sources.Length);
1955 Assert.AreEqual ("dtest-app.cs", sources [0]);
1956 Assert.AreEqual ("FOO", sources [1]);
1958 sources = l.Method.DeclaringType.GetSourceFiles (true);
1959 Assert.AreEqual (2, sources.Length);
1960 Assert.IsTrue (sources [0].EndsWith ("dtest-app.cs"));
1961 Assert.IsTrue (sources [1].EndsWith ("FOO"));
1965 public void Suspend () {
1968 Start (new string [] { "dtest-app.exe", "suspend-test" });
1970 Event e = run_until ("suspend");
1972 ThreadMirror main = e.Thread;
1980 // The debuggee should be suspended while it is running the infinite loop
1982 StackFrame frame = main.GetFrames ()[0];
1983 Assert.AreEqual ("suspend", frame.Method.Name);
1987 // resuming when not suspended
1988 AssertThrows<InvalidOperationException> (delegate () {
1998 public void AssemblyLoad () {
1999 Event e = run_until ("assembly_load");
2001 var load_req = vm.CreateAssemblyLoadRequest ();
2006 e = GetNextEvent ();
2007 Assert.IsInstanceOfType (typeof (AssemblyLoadEvent), e);
2008 Assert.IsTrue ((e as AssemblyLoadEvent).Assembly.Location.EndsWith ("System.dll"));
2010 var frames = e.Thread.GetFrames ();
2011 Assert.IsTrue (frames.Length > 0);
2012 Assert.AreEqual ("assembly_load", frames [0].Method.Name);
2016 public void CreateValue () {
2019 v = vm.CreateValue (1);
2020 Assert.AreEqual (vm, v.VirtualMachine);
2021 Assert.AreEqual (1, v.Value);
2023 v = vm.CreateValue (null);
2024 Assert.AreEqual (vm, v.VirtualMachine);
2025 Assert.AreEqual (null, v.Value);
2027 // Argument checking
2028 AssertThrows <ArgumentException> (delegate () {
2029 v = vm.CreateValue ("FOO");
2034 public void CreateString () {
2035 StringMirror s = vm.RootDomain.CreateString ("ABC");
2037 Assert.AreEqual (vm, s.VirtualMachine);
2038 Assert.AreEqual ("ABC", s.Value);
2039 Assert.AreEqual (vm.RootDomain, s.Domain);
2042 StringBuilder sb = new StringBuilder ();
2043 for (int i = 0; i < 1024; ++i)
2045 s = vm.RootDomain.CreateString (sb.ToString ());
2047 // Argument checking
2048 AssertThrows <ArgumentNullException> (delegate () {
2049 s = vm.RootDomain.CreateString (null);
2054 public void CreateBoxedValue () {
2055 ObjectMirror o = vm.RootDomain.CreateBoxedValue (new PrimitiveValue (vm, 42));
2057 Assert.AreEqual ("Int32", o.Type.Name);
2058 //AssertValue (42, m.GetValue (o.Type.GetField ("m_value")));
2060 // Argument checking
2061 AssertThrows <ArgumentNullException> (delegate () {
2062 vm.RootDomain.CreateBoxedValue (null);
2065 AssertThrows <ArgumentException> (delegate () {
2066 vm.RootDomain.CreateBoxedValue (o);
2071 public void Invoke () {
2072 Event e = run_until ("invoke1");
2074 StackFrame frame = e.Thread.GetFrames () [0];
2076 TypeMirror t = frame.Method.DeclaringType;
2077 ObjectMirror this_obj = (ObjectMirror)frame.GetThis ();
2079 TypeMirror t2 = frame.Method.GetParameters ()[0].ParameterType;
2085 m = t.GetMethod ("invoke_return_void");
2086 v = this_obj.InvokeMethod (e.Thread, m, null);
2090 m = t.GetMethod ("invoke_return_ref");
2091 v = this_obj.InvokeMethod (e.Thread, m, null);
2092 AssertValue ("ABC", v);
2095 m = t.GetMethod ("invoke_return_null");
2096 v = this_obj.InvokeMethod (e.Thread, m, null);
2097 AssertValue (null, v);
2100 m = t.GetMethod ("invoke_return_primitive");
2101 v = this_obj.InvokeMethod (e.Thread, m, null);
2102 AssertValue (42, v);
2105 m = t.GetMethod ("invoke_return_nullable");
2106 v = this_obj.InvokeMethod (e.Thread, m, null);
2107 Assert.IsInstanceOfType (typeof (StructMirror), v);
2108 var s = v as StructMirror;
2109 AssertValue (42, s.Fields [0]);
2110 AssertValue (true, s.Fields [1]);
2112 // pass nullable as this
2113 //m = vm.RootDomain.Corlib.GetType ("System.Object").GetMethod ("ToString");
2114 m = s.Type.GetMethod ("ToString");
2115 v = s.InvokeMethod (e.Thread, m, null);
2117 // return nullable null
2118 m = t.GetMethod ("invoke_return_nullable_null");
2119 v = this_obj.InvokeMethod (e.Thread, m, null);
2120 Assert.IsInstanceOfType (typeof (StructMirror), v);
2121 s = v as StructMirror;
2122 AssertValue (0, s.Fields [0]);
2123 AssertValue (false, s.Fields [1]);
2125 // pass nullable as this
2126 //m = vm.RootDomain.Corlib.GetType ("System.Object").GetMethod ("ToString");
2127 m = s.Type.GetMethod ("ToString");
2128 v = s.InvokeMethod (e.Thread, m, null);
2131 m = t.GetMethod ("invoke_pass_primitive");
2132 Value[] args = new Value [] {
2133 vm.CreateValue ((byte)Byte.MaxValue),
2134 vm.CreateValue ((sbyte)SByte.MaxValue),
2135 vm.CreateValue ((short)1),
2136 vm.CreateValue ((ushort)1),
2137 vm.CreateValue ((int)1),
2138 vm.CreateValue ((uint)1),
2139 vm.CreateValue ((long)1),
2140 vm.CreateValue ((ulong)1),
2141 vm.CreateValue ('A'),
2142 vm.CreateValue (true),
2143 vm.CreateValue (3.14f),
2144 vm.CreateValue (3.14) };
2146 v = this_obj.InvokeMethod (e.Thread, m, args);
2147 AssertValue ((int)Byte.MaxValue + (int)SByte.MaxValue + 1 + 1 + 1 + 1 + 1 + 1 + 'A' + 1 + 3 + 3, v);
2150 m = t.GetMethod ("invoke_pass_ref");
2151 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2152 AssertValue ("ABC", v);
2155 m = t.GetMethod ("invoke_pass_ref");
2156 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.CreateValue (null) });
2157 AssertValue (null, v);
2160 m = t.GetMethod ("invoke_static_pass_ref");
2161 v = t.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2162 AssertValue ("ABC", v);
2164 // static invoked using ObjectMirror.InvokeMethod
2165 m = t.GetMethod ("invoke_static_pass_ref");
2166 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2167 AssertValue ("ABC", v);
2169 // method which throws an exception
2171 m = t.GetMethod ("invoke_throws");
2172 v = this_obj.InvokeMethod (e.Thread, m, null);
2174 } catch (InvocationException ex) {
2175 Assert.AreEqual ("Exception", ex.Exception.Type.Name);
2180 m = t.GetMethod ("invoke_out");
2181 var out_task = this_obj.InvokeMethodAsyncWithResult (e.Thread, m, new Value [] { vm.CreateValue (1), vm.CreateValue (null) }, InvokeOptions.ReturnOutArgs);
2182 var out_args = out_task.Result.OutArgs;
2183 AssertValue (5, out_args [0]);
2184 Assert.IsTrue (out_args [1] is ArrayMirror);
2185 Assert.AreEqual (10, (out_args [1] as ArrayMirror).Length);
2187 // without ReturnOutArgs flag
2188 out_task = this_obj.InvokeMethodAsyncWithResult (e.Thread, m, new Value [] { vm.CreateValue (1), vm.CreateValue (null) });
2189 out_args = out_task.Result.OutArgs;
2190 Assert.IsNull (out_args);
2194 m = t.GetMethod (".ctor");
2195 v = t.InvokeMethod (e.Thread, m, null);
2196 Assert.IsInstanceOfType (typeof (ObjectMirror), v);
2197 Assert.AreEqual ("Tests", (v as ObjectMirror).Type.Name);
2200 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("ITest2");
2201 m = cl1.GetMethod ("invoke_iface");
2202 v = this_obj.InvokeMethod (e.Thread, m, null);
2203 AssertValue (42, v);
2206 m = t.BaseType.GetMethod ("virtual_method");
2207 v = this_obj.InvokeMethod (e.Thread, m, null, InvokeOptions.Virtual);
2208 AssertValue ("V2", v);
2210 // virtual call on static method
2211 m = t.GetMethod ("invoke_static_pass_ref");
2212 v = t.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") }, InvokeOptions.Virtual);
2213 AssertValue ("ABC", v);
2217 m = t.GetMethod ("invoke_pass_ref");
2218 var task = this_obj.InvokeMethodAsync (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2219 AssertValue ("ABC", task.Result);
2222 m = t.GetMethod ("invoke_static_pass_ref");
2223 task = t.InvokeMethodAsync (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2224 AssertValue ("ABC", task.Result);
2227 // Argument checking
2230 AssertThrows<ArgumentNullException> (delegate {
2231 m = t.GetMethod ("invoke_pass_ref");
2232 v = this_obj.InvokeMethod (null, m, new Value [] { vm.CreateValue (null) });
2236 AssertThrows<ArgumentNullException> (delegate {
2237 v = this_obj.InvokeMethod (e.Thread, null, new Value [] { vm.CreateValue (null) });
2240 // invalid number of arguments
2241 m = t.GetMethod ("invoke_pass_ref");
2242 AssertThrows<ArgumentException> (delegate {
2243 v = this_obj.InvokeMethod (e.Thread, m, null);
2246 // invalid type of argument (ref != primitive)
2247 m = t.GetMethod ("invoke_pass_ref");
2248 AssertThrows<ArgumentException> (delegate {
2249 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.CreateValue (1) });
2252 // invalid type of argument (primitive != primitive)
2253 m = t.GetMethod ("invoke_pass_primitive_2");
2254 AssertThrows<ArgumentException> (delegate {
2255 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.CreateValue (1) });
2258 // invoking a non-static method as static
2259 m = t.GetMethod ("invoke_pass_ref");
2260 AssertThrows<ArgumentException> (delegate {
2261 v = t.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2264 // invoking a method defined in another class
2265 m = t2.GetMethod ("invoke");
2266 AssertThrows<ArgumentException> (delegate {
2267 v = this_obj.InvokeMethod (e.Thread, m, null);
2272 public void InvokeVType () {
2273 Event e = run_until ("invoke1");
2275 StackFrame frame = e.Thread.GetFrames () [0];
2277 var s = frame.GetArgument (1) as StructMirror;
2279 TypeMirror t = s.Type;
2284 // Pass struct as this, receive int
2285 m = t.GetMethod ("invoke_return_int");
2286 v = s.InvokeMethod (e.Thread, m, null);
2287 AssertValue (42, v);
2289 // Pass boxed struct as this
2290 var boxed_this = t.NewInstance () as ObjectMirror;
2291 m = t.GetMethod ("invoke_return_int");
2292 v = boxed_this.InvokeMethod (e.Thread, m, null);
2295 // Pass struct as this, receive intptr
2296 m = t.GetMethod ("invoke_return_intptr");
2297 v = s.InvokeMethod (e.Thread, m, null);
2298 AssertValue (43, v);
2301 m = t.GetMethod ("invoke_static");
2302 v = t.InvokeMethod (e.Thread, m, null);
2305 // Pass generic struct as this
2306 s = frame.GetArgument (2) as StructMirror;
2308 m = t.GetMethod ("invoke_return_int");
2309 v = s.InvokeMethod (e.Thread, m, null);
2310 AssertValue (42, v);
2313 s = frame.GetArgument (1) as StructMirror;
2315 m = t.GetMethods ().First (method => method.Name == ".ctor" && method.GetParameters ().Length == 1);
2316 v = t.InvokeMethod (e.Thread, m, new Value [] { vm.CreateValue (1) });
2317 AssertValue (1, (v as StructMirror)["i"]);
2320 // Invoke a method which changes state
2321 s = frame.GetArgument (1) as StructMirror;
2323 m = t.GetMethod ("invoke_mutate");
2324 var task = s.InvokeMethodAsyncWithResult (e.Thread, m, null, InvokeOptions.ReturnOutThis);
2325 var out_this = task.Result.OutThis as StructMirror;
2326 AssertValue (5, out_this ["l"]);
2328 // Without the ReturnOutThis flag
2329 s = frame.GetArgument (1) as StructMirror;
2331 m = t.GetMethod ("invoke_mutate");
2332 task = s.InvokeMethodAsyncWithResult (e.Thread, m, null);
2333 out_this = task.Result.OutThis as StructMirror;
2334 Assert.AreEqual (null, out_this);
2337 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("ITest2");
2338 m = cl1.GetMethod ("invoke_iface");
2339 v = s.InvokeMethod (e.Thread, m, null);
2340 AssertValue (42, v);
2343 m = vm.RootDomain.Corlib.GetType ("System.Object").GetMethod ("ToString");
2344 v = s.InvokeMethod (e.Thread, m, null, InvokeOptions.Virtual);
2345 AssertValue ("42", v);
2350 public void BreakpointDuringInvoke () {
2351 Event e = run_until ("invoke1");
2353 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke2");
2354 Assert.IsNotNull (m);
2355 vm.SetBreakpoint (m, 0);
2357 StackFrame frame = e.Thread.GetFrames () [0];
2358 var o = frame.GetThis () as ObjectMirror;
2360 bool failed = false;
2362 bool finished = false;
2363 object wait = new object ();
2365 // Have to invoke in a separate thread as the invoke is suspended until we
2366 // resume after the breakpoint
2367 Thread t = new Thread (delegate () {
2369 o.InvokeMethod (e.Thread, m, null);
2375 Monitor.Pulse (wait);
2381 StackFrame invoke_frame = null;
2384 e = GetNextEvent ();
2385 Assert.IsInstanceOfType (typeof (BreakpointEvent), e);
2386 // Check stack trace support and invokes
2387 var frames = e.Thread.GetFrames ();
2388 invoke_frame = frames [0];
2389 Assert.AreEqual ("invoke2", frames [0].Method.Name);
2390 Assert.IsTrue (frames [0].IsDebuggerInvoke);
2391 Assert.AreEqual ("invoke1", frames [1].Method.Name);
2398 Monitor.Wait (wait);
2401 // Check that the invoke frames are no longer valid
2402 AssertThrows<InvalidStackFrameException> (delegate {
2403 invoke_frame.GetThis ();
2406 // Check InvokeOptions.DisableBreakpoints flag
2407 o.InvokeMethod (e.Thread, m, null, InvokeOptions.DisableBreakpoints);
2411 public void DisabledExceptionDuringInvoke () {
2412 Event e = run_until ("invoke_ex");
2414 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke_ex_inner");
2416 StackFrame frame = e.Thread.GetFrames () [0];
2417 var o = frame.GetThis () as ObjectMirror;
2419 var req = vm.CreateExceptionRequest (null);
2422 // Check InvokeOptions.DisableBreakpoints flag
2423 o.InvokeMethod (e.Thread, m, null, InvokeOptions.DisableBreakpoints);
2429 public void InvokeSingleThreaded () {
2432 Start (new string [] { "dtest-app.exe", "invoke-single-threaded" });
2434 Event e = run_until ("invoke_single_threaded_2");
2436 StackFrame f = e.Thread.GetFrames ()[0];
2438 var obj = f.GetThis () as ObjectMirror;
2440 // Check that the counter value incremented by the other thread does not increase
2441 // during the invoke.
2442 object counter1 = (obj.GetValue (obj.Type.GetField ("counter")) as PrimitiveValue).Value;
2444 var m = obj.Type.GetMethod ("invoke_return_void");
2445 obj.InvokeMethod (e.Thread, m, null, InvokeOptions.SingleThreaded);
2447 object counter2 = (obj.GetValue (obj.Type.GetField ("counter")) as PrimitiveValue).Value;
2449 Assert.AreEqual ((int)counter1, (int)counter2);
2451 // Test multiple invokes done in succession
2452 m = obj.Type.GetMethod ("invoke_return_void");
2453 obj.InvokeMethod (e.Thread, m, null, InvokeOptions.SingleThreaded);
2455 // Test events during single-threaded invokes
2456 vm.EnableEvents (EventType.TypeLoad);
2457 m = obj.Type.GetMethod ("invoke_type_load");
2458 obj.BeginInvokeMethod (e.Thread, m, null, InvokeOptions.SingleThreaded, delegate {
2462 e = GetNextEvent ();
2463 Assert.AreEqual (EventType.TypeLoad, e.EventType);
2466 List<Value> invoke_results;
2469 public void InvokeMultiple () {
2470 Event e = run_until ("invoke1");
2472 StackFrame frame = e.Thread.GetFrames () [0];
2474 TypeMirror t = frame.Method.DeclaringType;
2475 ObjectMirror this_obj = (ObjectMirror)frame.GetThis ();
2477 TypeMirror t2 = frame.Method.GetParameters ()[0].ParameterType;
2479 var methods = new MethodMirror [2];
2480 methods [0] = t.GetMethod ("invoke_return_ref");
2481 methods [1] = t.GetMethod ("invoke_return_primitive");
2483 invoke_results = new List<Value> ();
2485 var r = this_obj.BeginInvokeMultiple (e.Thread, methods, null, InvokeOptions.SingleThreaded, invoke_multiple_cb, this_obj);
2486 WaitHandle.WaitAll (new WaitHandle[] { r.AsyncWaitHandle });
2487 this_obj.EndInvokeMultiple (r);
2488 // The callback might still be running
2489 while (invoke_results.Count < 2) {
2492 if (invoke_results [0] is PrimitiveValue) {
2493 AssertValue ("ABC", invoke_results [1]);
2494 AssertValue (42, invoke_results [0]);
2496 AssertValue ("ABC", invoke_results [0]);
2497 AssertValue (42, invoke_results [1]);
2501 void invoke_multiple_cb (IAsyncResult ar) {
2502 ObjectMirror this_obj = (ObjectMirror)ar.AsyncState;
2504 var res = this_obj.EndInvokeMethod (ar);
2505 lock (invoke_results)
2506 invoke_results.Add (res);
2510 public void InvokeAbort () {
2513 Start (new string [] { "dtest-app.exe", "invoke-abort" });
2515 Event e = run_until ("invoke_abort");
2517 StackFrame f = e.Thread.GetFrames ()[0];
2519 var obj = f.GetThis () as ObjectMirror;
2521 var m = t.GetMethod ("invoke_abort_2");
2522 // Invoke multiple times to check that the subsequent invokes are aborted too
2523 var res = (IInvokeAsyncResult)obj.BeginInvokeMultiple (e.Thread, new MethodMirror[] { m, m, m, m }, null, InvokeOptions.None, delegate { }, null);
2526 AssertThrows<CommandException> (delegate {
2527 obj.EndInvokeMethod (res);
2532 public void GetThreads () {
2537 public void Threads () {
2538 Event e = run_until ("threads");
2540 Assert.AreEqual (ThreadState.Running, e.Thread.ThreadState);
2542 Assert.IsTrue (e.Thread.ThreadId > 0);
2544 Assert.AreEqual (e.Thread.TID, e.Thread.TID);
2546 vm.EnableEvents (EventType.ThreadStart, EventType.ThreadDeath);
2550 e = GetNextEvent ();
2551 Assert.IsInstanceOfType (typeof (ThreadStartEvent), e);
2552 var state = e.Thread.ThreadState;
2553 Assert.IsTrue (state == ThreadState.Running || state == ThreadState.Unstarted);
2557 e = GetNextEvent ();
2558 Assert.IsInstanceOfType (typeof (ThreadDeathEvent), e);
2559 Assert.AreEqual (ThreadState.Stopped, e.Thread.ThreadState);
2563 public void Frame_SetValue () {
2564 Event e = run_until ("locals2");
2566 StackFrame frame = e.Thread.GetFrames () [0];
2569 var l = frame.Method.GetLocal ("i");
2570 frame.SetValue (l, vm.CreateValue ((long)55));
2571 AssertValue (55, frame.GetValue (l));
2574 l = frame.Method.GetLocal ("s");
2575 frame.SetValue (l, vm.RootDomain.CreateString ("DEF"));
2576 AssertValue ("DEF", frame.GetValue (l));
2578 // argument as local
2579 l = frame.Method.GetLocal ("arg");
2580 frame.SetValue (l, vm.CreateValue (6));
2581 AssertValue (6, frame.GetValue (l));
2584 var p = frame.Method.GetParameters ()[1];
2585 frame.SetValue (p, vm.CreateValue (7));
2586 AssertValue (7, frame.GetValue (p));
2589 p = frame.Method.GetParameters ()[2];
2590 frame.SetValue (p, vm.RootDomain.CreateString ("DEF"));
2591 AssertValue ("DEF", frame.GetValue (p));
2594 p = frame.Method.GetParameters ()[3];
2595 frame.SetValue (p, vm.RootDomain.CreateString ("DEF2"));
2596 AssertValue ("DEF2", frame.GetValue (p));
2599 p = frame.Method.GetParameters ()[4];
2600 var v = frame.GetValue (p) as StructMirror;
2601 v ["i"] = vm.CreateValue (43);
2602 frame.SetValue (p, v);
2603 v = frame.GetValue (p) as StructMirror;
2604 AssertValue (43, v ["i"]);
2606 // argument checking
2609 AssertThrows<ArgumentNullException> (delegate () {
2610 frame.SetValue ((LocalVariable)null, vm.CreateValue (55));
2614 AssertThrows<ArgumentNullException> (delegate () {
2615 l = frame.Method.GetLocal ("i");
2616 frame.SetValue (l, null);
2619 // value of invalid type
2620 AssertThrows<ArgumentException> (delegate () {
2621 l = frame.Method.GetLocal ("i");
2622 frame.SetValue (l, vm.CreateValue (55));
2628 public void Frame_SetValue_Registers () {
2629 Event e = run_until ("locals6_1");
2631 StackFrame frame = e.Thread.GetFrames () [1];
2634 var l = frame.Method.GetLocal ("j");
2635 frame.SetValue (l, vm.CreateValue (99));
2636 AssertValue (99, frame.GetValue (l));
2638 // Check it during execution
2639 e = run_until ("locals6_2");
2640 frame = e.Thread.GetFrames () [0];
2641 AssertValue (99, frame.GetValue (frame.Method.GetParameters ()[0]));
2643 // Set it while in a frame which clobbers its register
2644 e = run_until ("locals6_3");
2645 frame = e.Thread.GetFrames () [1];
2646 frame.SetValue (l, vm.CreateValue (100));
2647 AssertValue (100, frame.GetValue (l));
2649 // Check it during execution
2650 e = run_until ("locals6_4");
2651 frame = e.Thread.GetFrames () [0];
2652 AssertValue (100, frame.GetValue (frame.Method.GetParameters ()[0]));
2654 // Signed byte value
2655 e = run_until ("locals6_5");
2656 frame = e.Thread.GetFrames () [1];
2657 var l2 = frame.Method.GetLocal ("sb");
2658 frame.SetValue (l2, vm.CreateValue ((sbyte)-99));
2659 AssertValue (-99, frame.GetValue (l2));
2661 // Check it during execution
2662 e = run_until ("locals6_6");
2663 frame = e.Thread.GetFrames () [0];
2664 AssertValue (-99, frame.GetValue (frame.Method.GetParameters ()[0]));
2668 public void InvokeRegress () {
2669 Event e = run_until ("invoke1");
2671 StackFrame frame = e.Thread.GetFrames () [0];
2673 TypeMirror t = frame.Method.DeclaringType;
2674 ObjectMirror this_obj = (ObjectMirror)frame.GetThis ();
2676 TypeMirror t2 = frame.Method.GetParameters ()[0].ParameterType;
2682 m = t.GetMethod ("invoke_return_void");
2683 v = this_obj.InvokeMethod (e.Thread, m, null);
2686 // Check that the stack frames remain valid during the invoke
2687 Assert.AreEqual ("Tests", (frame.GetThis () as ObjectMirror).Type.Name);
2689 // do another invoke
2690 m = t.GetMethod ("invoke_return_void");
2691 v = this_obj.InvokeMethod (e.Thread, m, null);
2694 // Try a single step after the invoke
2695 var req = create_step (e);
2696 req.Depth = StepDepth.Into;
2697 req.Size = StepSize.Line;
2703 // Step into invoke2
2705 e = GetNextEvent ();
2706 Assert.IsTrue (e is StepEvent);
2707 Assert.AreEqual ("invoke2", (e as StepEvent).Method.Name);
2711 frame = e.Thread.GetFrames () [0];
2715 public void Exceptions () {
2716 Event e = run_until ("exceptions");
2717 var req = vm.CreateExceptionRequest (null);
2722 e = GetNextEvent ();
2723 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2724 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2726 var frames = e.Thread.GetFrames ();
2727 Assert.AreEqual ("exceptions", frames [0].Method.Name);
2730 // exception type filter
2732 req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.ArgumentException"));
2735 // Skip the throwing of the second OverflowException
2738 e = GetNextEvent ();
2739 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2740 Assert.AreEqual ("ArgumentException", (e as ExceptionEvent).Exception.Type.Name);
2743 // exception type filter for subclasses
2744 req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.Exception"));
2749 e = GetNextEvent ();
2750 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2751 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2755 req.IncludeSubclasses = false;
2760 e = GetNextEvent ();
2761 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2762 Assert.AreEqual ("Exception", (e as ExceptionEvent).Exception.Type.Name);
2765 // Implicit exceptions
2766 req = vm.CreateExceptionRequest (null);
2771 e = GetNextEvent ();
2772 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2773 Assert.AreEqual ("NullReferenceException", (e as ExceptionEvent).Exception.Type.Name);
2776 // Single stepping after an exception
2777 req = vm.CreateExceptionRequest (null);
2782 e = GetNextEvent ();
2783 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2784 Assert.AreEqual ("Exception", (e as ExceptionEvent).Exception.Type.Name);
2785 frames = e.Thread.GetFrames ();
2786 Assert.AreEqual ("exceptions2", frames [0].Method.Name);
2789 var sreq = create_step (e);
2790 sreq.Depth = StepDepth.Over;
2791 sreq.Size = StepSize.Line;
2795 e = GetNextEvent ();
2796 Assert.IsInstanceOfType (typeof (StepEvent), e);
2797 frames = e.Thread.GetFrames ();
2798 Assert.AreEqual ("exceptions", frames [0].Method.Name);
2801 // Argument checking
2802 AssertThrows<ArgumentException> (delegate {
2803 vm.CreateExceptionRequest (e.Thread.Type);
2808 public void ExceptionFilter () {
2809 Event e = run_until ("exception_filter");
2811 MethodMirror m = entry_point.DeclaringType.GetMethod ("exception_filter_filter");
2812 Assert.IsNotNull (m);
2814 vm.SetBreakpoint (m, 0);
2818 e = GetNextEvent ();
2819 Assert.AreEqual (EventType.Breakpoint, e.EventType);
2820 Assert.IsTrue (e is BreakpointEvent);
2821 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
2823 var frames = e.Thread.GetFrames ();
2825 Assert.IsTrue (frames [0].Location.SourceFile.IndexOf ("dtest-app.cs") != -1);
2826 Assert.AreEqual ("exception_filter_filter", frames [0].Location.Method.Name);
2828 Assert.AreEqual (0, frames [1].Location.Method.MetadataToken);
2829 Assert.AreEqual (0x0f, frames [1].Location.ILOffset);
2831 Assert.AreEqual ("exception_filter_method", frames [2].Location.Method.Name);
2832 Assert.AreEqual (0x06, frames [2].Location.ILOffset);
2834 Assert.AreEqual (0, frames [3].Location.Method.MetadataToken, 0);
2835 Assert.AreEqual (0, frames [3].Location.ILOffset);
2837 Assert.AreEqual ("exception_filter", frames [4].Location.Method.Name);
2841 public void ExceptionFilter2 () {
2844 Start (new string [] { "dtest-excfilter.exe" });
2846 MethodMirror filter_method = entry_point.DeclaringType.GetMethod ("Filter");
2847 Assert.IsNotNull (filter_method);
2849 MethodMirror test_method = entry_point.DeclaringType.GetMethod ("Test");
2850 Assert.IsNotNull (test_method);
2852 vm.SetBreakpoint (filter_method, 0);
2856 var e = GetNextEvent ();
2857 Assert.AreEqual (EventType.Breakpoint, e.EventType);
2858 Assert.IsTrue (e is BreakpointEvent);
2859 Assert.AreEqual (filter_method.Name, (e as BreakpointEvent).Method.Name);
2861 var frames = e.Thread.GetFrames ();
2863 Assert.AreEqual (4, frames.Count ());
2865 Assert.AreEqual (filter_method.Name, frames [0].Location.Method.Name);
2866 Assert.AreEqual (20, frames [0].Location.LineNumber);
2867 Assert.AreEqual (0, frames [0].Location.ILOffset);
2869 Assert.AreEqual (test_method.Name, frames [1].Location.Method.Name);
2870 Assert.AreEqual (37, frames [1].Location.LineNumber);
2871 Assert.AreEqual (0x0b, frames [1].Location.ILOffset);
2873 Assert.AreEqual (test_method.Name, frames [2].Location.Method.Name);
2874 Assert.AreEqual (33, frames [2].Location.LineNumber);
2875 Assert.AreEqual (0x05, frames [2].Location.ILOffset);
2877 Assert.AreEqual (entry_point.Name, frames [3].Location.Method.Name);
2878 Assert.AreEqual (14, frames [3].Location.LineNumber);
2879 Assert.AreEqual (0x00, frames [3].Location.ILOffset);
2887 public void EventSets () {
2889 // Create two filter which both match the same exception
2891 Event e = run_until ("exceptions");
2893 var req = vm.CreateExceptionRequest (null);
2896 var req2 = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.OverflowException"));
2901 var es = vm.GetNextEventSet ();
2902 Assert.AreEqual (2, es.Events.Length);
2905 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2906 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2909 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2910 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2917 // Test single threaded invokes during processing of nullref exceptions.
2918 // These won't work if the exception handling is done from the sigsegv signal
2919 // handler, since the sigsegv signal is disabled until control returns from the
2923 [Category ("only3")]
2924 public void NullRefExceptionAndSingleThreadedInvoke () {
2925 Event e = run_until ("exceptions");
2926 var req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.NullReferenceException"));
2931 e = GetNextEvent ();
2932 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2933 Assert.AreEqual ("NullReferenceException", (e as ExceptionEvent).Exception.Type.Name);
2935 var ex = (e as ExceptionEvent).Exception;
2936 var tostring_method = vm.RootDomain.Corlib.GetType ("System.Object").GetMethod ("ToString");
2937 ex.InvokeMethod (e.Thread, tostring_method, null, InvokeOptions.SingleThreaded);
2941 public void Domains () {
2944 Start (new string [] { "dtest-app.exe", "domain-test" });
2946 vm.EnableEvents (EventType.AppDomainCreate, EventType.AppDomainUnload, EventType.AssemblyUnload);
2948 Event e = run_until ("domains");
2952 e = GetNextEvent ();
2953 Assert.IsInstanceOfType (typeof (AppDomainCreateEvent), e);
2955 var domain = (e as AppDomainCreateEvent).Domain;
2957 // Check the object type
2958 e = run_until ("domains_2");
2959 var frame = e.Thread.GetFrames ()[0];
2960 var o = frame.GetArgument (0) as ObjectMirror;
2961 Assert.AreEqual ("CrossDomain", o.Type.Name);
2963 // Do a remoting invoke
2964 var cross_domain_type = o.Type;
2965 var v = o.InvokeMethod (e.Thread, cross_domain_type.GetMethod ("invoke_3"), null);
2966 AssertValue (42, v);
2968 // Run until the callback in the domain
2969 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke_in_domain");
2970 Assert.IsNotNull (m);
2971 vm.SetBreakpoint (m, 0);
2975 e = GetNextEvent ();
2976 if (e is BreakpointEvent)
2980 Assert.AreEqual ("invoke_in_domain", (e as BreakpointEvent).Method.Name);
2982 // d_method is from another domain
2983 MethodMirror d_method = (e as BreakpointEvent).Method;
2984 Assert.IsTrue (m != d_method);
2986 var frames = e.Thread.GetFrames ();
2987 Assert.AreEqual ("invoke_in_domain", frames [0].Method.Name);
2988 Assert.AreEqual (domain, frames [0].Domain);
2989 Assert.AreEqual ("invoke", frames [1].Method.Name);
2990 Assert.AreEqual ("domains", frames [2].Method.Name);
2991 Assert.AreEqual (vm.RootDomain, frames [2].Domain);
2993 // Test breakpoints on already JITted methods in other domains
2994 m = entry_point.DeclaringType.GetMethod ("invoke_in_domain_2");
2995 Assert.IsNotNull (m);
2996 vm.SetBreakpoint (m, 0);
3000 e = GetNextEvent ();
3001 if (e is BreakpointEvent)
3005 Assert.AreEqual ("invoke_in_domain_2", (e as BreakpointEvent).Method.Name);
3007 // This is empty when receiving the AppDomainCreateEvent
3008 Assert.AreEqual ("domain", domain.FriendlyName);
3010 // Run until the unload
3013 e = GetNextEvent ();
3014 if (e is AssemblyUnloadEvent) {
3020 Assert.IsInstanceOfType (typeof (AppDomainUnloadEvent), e);
3021 Assert.AreEqual (domain, (e as AppDomainUnloadEvent).Domain);
3023 // Run past the unload
3024 e = run_until ("domains_3");
3026 // Test access to unloaded types
3027 // FIXME: Add an exception type for this
3028 AssertThrows<Exception> (delegate {
3029 d_method.DeclaringType.GetValue (d_method.DeclaringType.GetField ("static_i"));
3032 // Check that .Domain is accessible for stack frames with native transitions
3033 e = run_until ("called_from_invoke");
3034 ThreadMirror.NativeTransitions = true;
3035 foreach (var f in e.Thread.GetFrames ()) {
3041 public void DynamicMethods () {
3042 Event e = run_until ("dyn_call");
3044 var m = e.Thread.GetFrames ()[1].Method;
3045 Assert.AreEqual ("dyn_method", m.Name);
3047 // Test access to IL
3048 var body = m.GetMethodBody ();
3050 ILInstruction ins = body.Instructions [0];
3051 Assert.AreEqual (OpCodes.Ldstr, ins.OpCode);
3052 Assert.AreEqual ("FOO", ins.Operand);
3056 public void RefEmit () {
3059 Start (new string [] { "dtest-app.exe", "ref-emit-test" });
3061 Event e = run_until ("ref_emit_call");
3063 var m = e.Thread.GetFrames ()[1].Method;
3064 Assert.AreEqual ("ref_emit_method", m.Name);
3066 // Test access to IL
3067 var body = m.GetMethodBody ();
3071 ins = body.Instructions [0];
3072 Assert.AreEqual (OpCodes.Ldstr, ins.OpCode);
3073 Assert.AreEqual ("FOO", ins.Operand);
3075 ins = body.Instructions [1];
3076 Assert.AreEqual (OpCodes.Call, ins.OpCode);
3077 Assert.IsInstanceOfType (typeof (MethodMirror), ins.Operand);
3078 Assert.AreEqual ("ref_emit_call", (ins.Operand as MethodMirror).Name);
3082 public void IsAttached () {
3083 var f = entry_point.DeclaringType.GetField ("is_attached");
3085 Event e = run_until ("Main");
3087 AssertValue (true, entry_point.DeclaringType.GetValue (f));
3091 public void StackTraceInNative () {
3092 // Check that stack traces can be produced for threads in native code
3095 Start (new string [] { "dtest-app.exe", "frames-in-native" });
3097 var e = run_until ("frames_in_native");
3099 // FIXME: This is racy
3106 StackFrame[] frames = e.Thread.GetFrames ();
3108 int frame_index = -1;
3109 for (int i = 0; i < frames.Length; ++i) {
3110 if (frames [i].Method.Name == "Sleep") {
3116 Assert.IsTrue (frame_index != -1);
3117 Assert.AreEqual ("Sleep", frames [frame_index].Method.Name);
3118 Assert.AreEqual ("frames_in_native", frames [frame_index + 1].Method.Name);
3119 Assert.AreEqual ("Main", frames [frame_index + 2].Method.Name);
3121 // Check that invokes are disabled for such threads
3122 TypeMirror t = frames [frame_index + 1].Method.DeclaringType;
3124 var m = t.GetMethod ("invoke_static_return_void");
3125 AssertThrows<InvalidOperationException> (delegate {
3126 t.InvokeMethod (e.Thread, m, null);
3129 // Check that the frame info is invalidated
3130 run_until ("frames_in_native_2");
3132 AssertThrows<InvalidStackFrameException> (delegate {
3133 Console.WriteLine (frames [frame_index].GetThis ());
3138 public void VirtualMachine_CreateEnumMirror () {
3139 var e = run_until ("o1");
3140 var frame = e.Thread.GetFrames () [0];
3142 object val = frame.GetThis ();
3143 Assert.IsTrue (val is ObjectMirror);
3144 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
3145 ObjectMirror o = (val as ObjectMirror);
3147 FieldInfoMirror field = o.Type.GetField ("field_enum");
3148 Value f = o.GetValue (field);
3149 TypeMirror enumType = (f as EnumMirror).Type;
3151 o.SetValue (field, vm.CreateEnumMirror (enumType, vm.CreateValue (1)));
3152 f = o.GetValue (field);
3153 Assert.AreEqual (1, (f as EnumMirror).Value);
3155 // Argument checking
3156 AssertThrows<ArgumentNullException> (delegate () {
3157 vm.CreateEnumMirror (enumType, null);
3160 AssertThrows<ArgumentNullException> (delegate () {
3161 vm.CreateEnumMirror (null, vm.CreateValue (1));
3165 AssertThrows<ArgumentException> (delegate () {
3166 vm.CreateEnumMirror (enumType, vm.CreateValue (null));
3169 // value of a wrong type
3170 AssertThrows<ArgumentException> (delegate () {
3171 vm.CreateEnumMirror (enumType, vm.CreateValue ((long)1));
3176 public void VirtualMachine_EnableEvents_Breakpoint () {
3177 AssertThrows<ArgumentException> (delegate () {
3178 vm.EnableEvents (EventType.Breakpoint);
3183 public void SingleStepRegress654694 () {
3186 MethodMirror m = entry_point.DeclaringType.GetMethod ("ss_regress_654694");
3187 foreach (Location l in m.Locations) {
3188 if (l.ILOffset > 0 && il_offset == -1)
3189 il_offset = l.ILOffset;
3192 Event e = run_until ("ss_regress_654694");
3194 Assert.IsNotNull (m);
3195 vm.SetBreakpoint (m, il_offset);
3199 e = GetNextEvent ();
3200 Assert.IsTrue (e is BreakpointEvent);
3202 var req = create_step (e);
3203 req.Depth = StepDepth.Over;
3204 req.Size = StepSize.Line;
3209 e = GetNextEvent ();
3210 Assert.IsTrue (e is StepEvent);
3216 public void DebugBreak () {
3217 vm.EnableEvents (EventType.UserBreak);
3222 var e = GetNextEvent ();
3223 Assert.IsTrue (e is UserBreakEvent);
3227 public void DebugLog () {
3228 vm.EnableEvents (EventType.UserLog);
3233 var e = GetNextEvent ();
3234 Assert.IsTrue (e is UserLogEvent);
3235 var le = e as UserLogEvent;
3237 Assert.AreEqual (5, le.Level);
3238 Assert.AreEqual ("A", le.Category);
3239 Assert.AreEqual ("B", le.Message);
3243 public void TypeGetMethodsByNameFlags () {
3245 var assembly = entry_point.DeclaringType.Assembly;
3246 var type = assembly.GetType ("Tests3");
3248 Assert.IsNotNull (type);
3250 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.Public, false);
3251 Assert.AreEqual (1, mm.Length, "#1");
3252 Assert.AreEqual ("M1", mm[0].Name, "#2");
3254 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.NonPublic, false);
3255 Assert.AreEqual (1, mm.Length, "#3");
3256 Assert.AreEqual ("M2", mm[0].Name, "#4");
3258 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.Public, false);
3259 Assert.AreEqual (7, mm.Length, "#5"); //M3 plus Equals, GetHashCode, GetType, ToString, .ctor
3261 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly, false);
3262 Assert.AreEqual (2, mm.Length, "#7");
3264 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly, false);
3265 Assert.AreEqual (1, mm.Length, "#9");
3267 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly, false);
3268 Assert.AreEqual (5, mm.Length, "#11");
3271 mm = type.GetMethodsByNameFlags ("M1", BindingFlags.Static | BindingFlags.Public, false);
3272 Assert.AreEqual (1, mm.Length, "#12");
3273 Assert.AreEqual ("M1", mm[0].Name, "#13");
3275 mm = type.GetMethodsByNameFlags ("m1", BindingFlags.Static | BindingFlags.Public, true);
3276 Assert.AreEqual (1, mm.Length, "#14");
3277 Assert.AreEqual ("M1", mm[0].Name, "#15");
3279 mm = type.GetMethodsByNameFlags ("M1", BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, false);
3280 Assert.AreEqual (1, mm.Length, "#16");
3281 Assert.AreEqual ("M1", mm[0].Name, "#17");
3285 [Category ("only88")]
3286 public void TypeLoadSourceFileFilter () {
3287 Event e = run_until ("type_load");
3289 if (!vm.Version.AtLeast (2, 7))
3292 string srcfile = (e as BreakpointEvent).Method.DeclaringType.GetSourceFiles (true)[0];
3294 var req = vm.CreateTypeLoadRequest ();
3295 req.SourceFileFilter = new string [] { srcfile.ToUpper () };
3299 e = GetNextEvent ();
3300 Assert.IsTrue (e is TypeLoadEvent);
3301 Assert.AreEqual ("TypeLoadClass", (e as TypeLoadEvent).Type.FullName);
3305 public void TypeLoadTypeNameFilter () {
3306 Event e = run_until ("type_load");
3308 var req = vm.CreateTypeLoadRequest ();
3309 req.TypeNameFilter = new string [] { "TypeLoadClass2" };
3313 e = GetNextEvent ();
3314 Assert.IsTrue (e is TypeLoadEvent);
3315 Assert.AreEqual ("TypeLoadClass2", (e as TypeLoadEvent).Type.FullName);
3319 public void GetTypesForSourceFile () {
3322 var types = vm.GetTypesForSourceFile ("dtest-app.cs", false);
3323 Assert.IsTrue (types.Any (t => t.FullName == "Tests"));
3324 Assert.IsFalse (types.Any (t => t.FullName == "System.Int32"));
3326 types = vm.GetTypesForSourceFile ("DTEST-app.cs", true);
3327 Assert.IsTrue (types.Any (t => t.FullName == "Tests"));
3328 Assert.IsFalse (types.Any (t => t.FullName == "System.Int32"));
3332 public void GetTypesNamed () {
3335 var types = vm.GetTypes ("Tests", false);
3336 Assert.AreEqual (1, types.Count);
3337 Assert.AreEqual ("Tests", types [0].FullName);
3339 types = vm.GetTypes ("System.Exception", false);
3340 Assert.AreEqual (1, types.Count);
3341 Assert.AreEqual ("System.Exception", types [0].FullName);
3345 public void String_GetValue () {
3350 var e = run_until ("arg2");
3352 var frame = e.Thread.GetFrames () [0];
3354 val = frame.GetArgument (6);
3355 Assert.AreEqual ('\0'.ToString () + "A", (val as StringMirror).Value);
3359 public void String_GetChars () {
3363 var e = run_until ("arg2");
3365 var frame = e.Thread.GetFrames () [0];
3367 val = frame.GetArgument (0);
3368 Assert.IsTrue (val is StringMirror);
3369 AssertValue ("FOO", val);
3370 var s = (val as StringMirror);
3371 Assert.AreEqual (3, s.Length);
3373 var c = s.GetChars (0, 2);
3374 Assert.AreEqual (2, c.Length);
3375 Assert.AreEqual ('F', c [0]);
3376 Assert.AreEqual ('O', c [1]);
3378 AssertThrows<ArgumentException> (delegate () {
3384 public void GetInterfaces () {
3385 var e = run_until ("arg2");
3387 var frame = e.Thread.GetFrames () [0];
3389 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("TestIfaces");
3390 var ifaces = cl1.GetInterfaces ();
3391 Assert.AreEqual (1, ifaces.Length);
3392 Assert.AreEqual ("ITest", ifaces [0].Name);
3394 var cl2 = cl1.GetMethod ("Baz").ReturnType;
3395 var ifaces2 = cl2.GetInterfaces ();
3396 Assert.AreEqual (1, ifaces2.Length);
3397 Assert.AreEqual ("ITest`1", ifaces2 [0].Name);
3401 public void GetInterfaceMap () {
3402 var e = run_until ("arg2");
3404 var frame = e.Thread.GetFrames () [0];
3406 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("TestIfaces");
3407 var iface = cl1.Assembly.GetType ("ITest");
3408 var map = cl1.GetInterfaceMap (iface);
3409 Assert.AreEqual (cl1, map.TargetType);
3410 Assert.AreEqual (iface, map.InterfaceType);
3411 Assert.AreEqual (2, map.InterfaceMethods.Length);
3412 Assert.AreEqual (2, map.TargetMethods.Length);
3416 public void StackAlloc_Breakpoints_Regress2775 () {
3417 // Check that breakpoints on arm don't overwrite stackalloc-ed memory
3418 var e = run_until ("regress_2755");
3420 var frame = e.Thread.GetFrames () [0];
3422 // This breaks at the call site
3423 vm.SetBreakpoint (m, m.Locations [2].ILOffset);
3426 var e2 = GetNextEvent ();
3427 Assert.IsTrue (e2 is BreakpointEvent);
3429 e = run_until ("regress_2755_3");
3430 frame = e.Thread.GetFrames () [1];
3431 var res = frame.GetValue (m.GetLocal ("sum"));
3432 AssertValue (0, res);
3436 public void MethodInfo () {
3437 Event e = run_until ("locals2");
3439 StackFrame frame = e.Thread.GetFrames () [0];
3440 var m = frame.Method;
3442 Assert.IsTrue (m.IsGenericMethod);
3443 Assert.IsFalse (m.IsGenericMethodDefinition);
3445 var args = m.GetGenericArguments ();
3446 Assert.AreEqual (1, args.Length);
3447 Assert.AreEqual ("String", args [0].Name);
3449 var gmd = m.GetGenericMethodDefinition ();
3450 Assert.IsTrue (gmd.IsGenericMethod);
3451 Assert.IsTrue (gmd.IsGenericMethodDefinition);
3452 Assert.AreEqual (gmd, gmd.GetGenericMethodDefinition ());
3454 args = gmd.GetGenericArguments ();
3455 Assert.AreEqual (1, args.Length);
3456 Assert.AreEqual ("T", args [0].Name);
3458 var attrs = m.GetCustomAttributes (true);
3459 Assert.AreEqual (1, attrs.Length);
3460 Assert.AreEqual ("StateMachineAttribute", attrs [0].Constructor.DeclaringType.Name);
3464 public void UnhandledException () {
3467 Start (new string [] { "dtest-app.exe", "unhandled-exception" });
3469 var req = vm.CreateExceptionRequest (null, false, true);
3472 var e = run_until ("unhandled_exception");
3475 var e2 = GetNextEvent ();
3476 Assert.IsTrue (e2 is ExceptionEvent);
3483 public void UnhandledException_2 () {
3486 Start (new string [] { "dtest-app.exe", "unhandled-exception-endinvoke" });
3488 var req = vm.CreateExceptionRequest (null, false, true);
3491 MethodMirror m = entry_point.DeclaringType.GetMethod ("unhandled_exception_endinvoke_2");
3492 Assert.IsNotNull (m);
3493 vm.SetBreakpoint (m, m.ILOffsets [0]);
3495 var e = run_until ("unhandled_exception_endinvoke");
3498 var e2 = GetNextEvent ();
3499 Assert.IsFalse (e2 is ExceptionEvent);
3507 public void UnhandledExceptionUserCode () {
3510 // Exceptions caught in non-user code are treated as unhandled
3511 Start (new string [] { "dtest-app.exe", "unhandled-exception-user" });
3513 var req = vm.CreateExceptionRequest (null, false, true);
3514 req.AssemblyFilter = new List<AssemblyMirror> () { entry_point.DeclaringType.Assembly };
3517 var e = run_until ("unhandled_exception_user");
3520 var e2 = GetNextEvent ();
3521 Assert.IsTrue (e2 is ExceptionEvent);
3529 public void GCWhileSuspended () {
3530 // Check that objects are kept alive during suspensions
3531 Event e = run_until ("gc_suspend_1");
3533 MethodMirror m = entry_point.DeclaringType.GetMethod ("gc_suspend_invoke");
3535 var o = entry_point.DeclaringType.GetValue (entry_point.DeclaringType.GetField ("gc_suspend_field")) as ObjectMirror;
3536 //Console.WriteLine (o);
3538 StackFrame frame = e.Thread.GetFrames () [0];
3539 TypeMirror t = frame.Method.DeclaringType;
3540 for (int i = 0; i < 10; ++i)
3541 t.InvokeMethod (e.Thread, m, new Value [] { });
3543 // This throws an exception if the object is collected
3544 long addr = o.Address;
3546 var o2 = entry_point.DeclaringType.GetValue (entry_point.DeclaringType.GetField ("gc_suspend_field")) as ObjectMirror;
3551 public void MakeGenericMethod () {
3552 Event e = run_until ("bp1");
3554 var intm = vm.RootDomain.GetCorrespondingType (typeof (int));
3555 var stringm = vm.RootDomain.GetCorrespondingType (typeof (string));
3556 var gm = entry_point.DeclaringType.GetMethod ("generic_method");
3557 var res = gm.MakeGenericMethod (new TypeMirror [] { stringm });
3558 var args = res.GetGenericArguments ();
3559 Assert.AreEqual (1, args.Length);
3560 Assert.AreEqual (stringm, args [0]);
3563 AssertThrows<ArgumentNullException> (delegate {
3564 gm.MakeGenericMethod (null);
3566 AssertThrows<ArgumentNullException> (delegate {
3567 gm.MakeGenericMethod (new TypeMirror [] { null });
3569 AssertThrows<ArgumentException> (delegate {
3570 gm.MakeGenericMethod (new TypeMirror [] { stringm, stringm });
3572 AssertThrows<InvalidOperationException> (delegate {
3573 gm.MakeGenericMethod (new TypeMirror [] { intm });
3575 AssertThrows<InvalidOperationException> (delegate {
3576 entry_point.DeclaringType.GetMethod ("Main").MakeGenericMethod (new TypeMirror [] { intm });
3581 public void InspectThreadSuspenedOnWaitOne () {
3583 Start (true, "dtest-app.exe", "wait-one" );
3585 ThreadMirror.NativeTransitions = true;
3587 var evt = run_until ("wait_one");
3588 Assert.IsNotNull (evt, "#1");
3590 var thread = evt.Thread;
3591 Assert.AreEqual (ThreadState.Running, thread.ThreadState, "#1.1");
3593 var frames = thread.GetFrames ();
3594 Assert.IsNotNull (frames, "#2");
3595 Assert.AreEqual (2, frames.Length, "#3");
3596 Assert.AreEqual ("wait_one", frames [0].Method.Name, "#4");
3597 Assert.AreEqual ("Main", frames [1].Method.Name, "#5");
3601 Thread.Sleep (500); //FIXME this is racy, maybe single step? or something?
3604 Assert.AreEqual (ThreadState.WaitSleepJoin, thread.ThreadState, "#6");
3606 frames = thread.GetFrames ();
3607 Assert.AreEqual (4, frames.Length, "#7");
3608 Assert.AreEqual ("WaitOne_internal", frames [0].Method.Name, "#8");
3609 Assert.AreEqual ("WaitOne", frames [1].Method.Name, "#8.1");
3610 Assert.AreEqual ("wait_one", frames [2].Method.Name, "#9");
3611 Assert.AreEqual ("Main", frames [3].Method.Name, "#10");
3614 var frame = frames [0];
3615 Assert.IsTrue (frame.IsNativeTransition, "#11.1");
3618 Assert.Fail ("Known limitation - can't get info from m2n frames");
3619 } catch (AbsentInformationException) {}
3622 Assert.IsFalse (frame.IsNativeTransition, "#12.1");
3623 var wait_one_this = frame.GetThis ();
3624 Assert.IsNotNull (wait_one_this, "#12.2");
3627 var locals = frame.GetVisibleVariables ();
3628 Assert.AreEqual (1, locals.Count, "#13.1");
3630 var local_0 = frame.GetValue (locals [0]);
3631 Assert.IsNotNull (local_0, "#13.2");
3633 Assert.AreEqual (wait_one_this, local_0, "#14.2");
3637 public void GetMethodBody () {
3638 var bevent = run_until ("Main");
3640 var m = bevent.Method.DeclaringType.GetMethod ("get_IntProperty");
3641 var body = m.GetMethodBody ();
3642 foreach (var ins in body.Instructions) {
3643 if (ins.OpCode == OpCodes.Ldfld) {
3644 var field = (FieldInfoMirror)ins.Operand;
3645 Assert.AreEqual ("field_i", field.Name);
3651 public void EvaluateMethod () {
3652 var bevent = run_until ("evaluate_method_2");
3654 var m = bevent.Method.DeclaringType.GetMethod ("get_IntProperty");
3656 var this_obj = bevent.Thread.GetFrames ()[0].GetThis ();
3657 var v = m.Evaluate (this_obj, null);
3658 AssertValue (42, v);
3662 public void SetIP () {
3663 var bevent = run_until ("set_ip_1");
3665 var invalid_loc = bevent.Thread.GetFrames ()[0].Location;
3667 var req = create_step (bevent);
3668 var e = step_out ();
3670 var frames = e.Thread.GetFrames ();
3671 var locs = frames [0].Method.Locations;
3672 var next_loc = locs.First (l => (l.LineNumber == frames [0].Location.LineNumber + 2));
3674 e.Thread.SetIP (next_loc);
3676 /* Check that i ++; j = 5; was skipped */
3677 bevent = run_until ("set_ip_2");
3678 var f = bevent.Thread.GetFrames ()[1];
3679 AssertValue (2, f.GetValue (f.Method.GetLocal ("i")));
3680 AssertValue (0, f.GetValue (f.Method.GetLocal ("j")));
3683 AssertThrows<ArgumentNullException> (delegate {
3684 e.Thread.SetIP (null);
3687 AssertThrows<ArgumentException> (delegate {
3688 e.Thread.SetIP (invalid_loc);
3693 public void SetIPSingleStep () {
3694 // Check that single stepping after set-ip steps from the new ip
3695 var bevent = run_until ("set_ip_1");
3697 var invalid_loc = bevent.Thread.GetFrames ()[0].Location;
3699 var req = create_step (bevent);
3700 req.Size = StepSize.Line;
3701 var e = step_out ();
3703 var frames = e.Thread.GetFrames ();
3704 var locs = frames [0].Method.Locations;
3705 var prev_loc = locs.First (l => (l.LineNumber == frames [0].Location.LineNumber - 3));
3706 AssertValue (2, frames [0].GetValue (frames [0].Method.GetLocal ("i")));
3708 // Set back the ip to the first i ++; line
3709 e.Thread.SetIP (prev_loc);
3712 var f = e.Thread.GetFrames ()[0];
3713 AssertValue (3, f.GetValue (f.Method.GetLocal ("i")));
3717 public void NewInstanceNoCtor () {
3718 var bevent = run_until ("Main");
3720 var stype = bevent.Method.DeclaringType.Assembly.GetType ("AStruct");
3721 var obj = stype.NewInstance ();
3722 Assert.IsTrue (obj is ObjectMirror);
3723 Assert.AreEqual ("AStruct", (obj as ObjectMirror).Type.Name);
3727 public void StaticCtorFilterInCctor () {
3728 // Check that single stepping when in a cctor only ignores
3729 // other cctors, not the current one
3730 var bevent = run_until ("step_filters");
3732 var assembly = entry_point.DeclaringType.Assembly;
3733 var type = assembly.GetType ("Tests/ClassWithCctor");
3734 var cctor = type.GetMethod (".cctor");
3735 vm.SetBreakpoint (cctor, 0);
3738 var e = vm.GetNextEvent ();
3739 Assert.IsTrue (e is BreakpointEvent);
3741 var req = create_step (e);
3742 req.Filter = StepFilter.StaticCtor;
3744 // Make sure we are still in the cctor
3745 Assert.AreEqual (".cctor", e.Thread.GetFrames ()[0].Location.Method.Name);