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 GetThreads () {
2515 public void Threads () {
2516 Event e = run_until ("threads");
2518 Assert.AreEqual (ThreadState.Running, e.Thread.ThreadState);
2520 Assert.IsTrue (e.Thread.ThreadId > 0);
2522 Assert.AreEqual (e.Thread.TID, e.Thread.TID);
2524 vm.EnableEvents (EventType.ThreadStart, EventType.ThreadDeath);
2528 e = GetNextEvent ();
2529 Assert.IsInstanceOfType (typeof (ThreadStartEvent), e);
2530 var state = e.Thread.ThreadState;
2531 Assert.IsTrue (state == ThreadState.Running || state == ThreadState.Unstarted);
2535 e = GetNextEvent ();
2536 Assert.IsInstanceOfType (typeof (ThreadDeathEvent), e);
2537 Assert.AreEqual (ThreadState.Stopped, e.Thread.ThreadState);
2541 public void Frame_SetValue () {
2542 Event e = run_until ("locals2");
2544 StackFrame frame = e.Thread.GetFrames () [0];
2547 var l = frame.Method.GetLocal ("i");
2548 frame.SetValue (l, vm.CreateValue ((long)55));
2549 AssertValue (55, frame.GetValue (l));
2552 l = frame.Method.GetLocal ("s");
2553 frame.SetValue (l, vm.RootDomain.CreateString ("DEF"));
2554 AssertValue ("DEF", frame.GetValue (l));
2556 // argument as local
2557 l = frame.Method.GetLocal ("arg");
2558 frame.SetValue (l, vm.CreateValue (6));
2559 AssertValue (6, frame.GetValue (l));
2562 var p = frame.Method.GetParameters ()[1];
2563 frame.SetValue (p, vm.CreateValue (7));
2564 AssertValue (7, frame.GetValue (p));
2567 p = frame.Method.GetParameters ()[2];
2568 frame.SetValue (p, vm.RootDomain.CreateString ("DEF"));
2569 AssertValue ("DEF", frame.GetValue (p));
2572 p = frame.Method.GetParameters ()[3];
2573 frame.SetValue (p, vm.RootDomain.CreateString ("DEF2"));
2574 AssertValue ("DEF2", frame.GetValue (p));
2577 p = frame.Method.GetParameters ()[4];
2578 var v = frame.GetValue (p) as StructMirror;
2579 v ["i"] = vm.CreateValue (43);
2580 frame.SetValue (p, v);
2581 v = frame.GetValue (p) as StructMirror;
2582 AssertValue (43, v ["i"]);
2584 // argument checking
2587 AssertThrows<ArgumentNullException> (delegate () {
2588 frame.SetValue ((LocalVariable)null, vm.CreateValue (55));
2592 AssertThrows<ArgumentNullException> (delegate () {
2593 l = frame.Method.GetLocal ("i");
2594 frame.SetValue (l, null);
2597 // value of invalid type
2598 AssertThrows<ArgumentException> (delegate () {
2599 l = frame.Method.GetLocal ("i");
2600 frame.SetValue (l, vm.CreateValue (55));
2606 public void Frame_SetValue_Registers () {
2607 Event e = run_until ("locals6_1");
2609 StackFrame frame = e.Thread.GetFrames () [1];
2612 var l = frame.Method.GetLocal ("j");
2613 frame.SetValue (l, vm.CreateValue (99));
2614 AssertValue (99, frame.GetValue (l));
2616 // Check it during execution
2617 e = run_until ("locals6_2");
2618 frame = e.Thread.GetFrames () [0];
2619 AssertValue (99, frame.GetValue (frame.Method.GetParameters ()[0]));
2621 // Set it while in a frame which clobbers its register
2622 e = run_until ("locals6_3");
2623 frame = e.Thread.GetFrames () [1];
2624 frame.SetValue (l, vm.CreateValue (100));
2625 AssertValue (100, frame.GetValue (l));
2627 // Check it during execution
2628 e = run_until ("locals6_4");
2629 frame = e.Thread.GetFrames () [0];
2630 AssertValue (100, frame.GetValue (frame.Method.GetParameters ()[0]));
2632 // Signed byte value
2633 e = run_until ("locals6_5");
2634 frame = e.Thread.GetFrames () [1];
2635 var l2 = frame.Method.GetLocal ("sb");
2636 frame.SetValue (l2, vm.CreateValue ((sbyte)-99));
2637 AssertValue (-99, frame.GetValue (l2));
2639 // Check it during execution
2640 e = run_until ("locals6_6");
2641 frame = e.Thread.GetFrames () [0];
2642 AssertValue (-99, frame.GetValue (frame.Method.GetParameters ()[0]));
2646 public void InvokeRegress () {
2647 Event e = run_until ("invoke1");
2649 StackFrame frame = e.Thread.GetFrames () [0];
2651 TypeMirror t = frame.Method.DeclaringType;
2652 ObjectMirror this_obj = (ObjectMirror)frame.GetThis ();
2654 TypeMirror t2 = frame.Method.GetParameters ()[0].ParameterType;
2660 m = t.GetMethod ("invoke_return_void");
2661 v = this_obj.InvokeMethod (e.Thread, m, null);
2664 // Check that the stack frames remain valid during the invoke
2665 Assert.AreEqual ("Tests", (frame.GetThis () as ObjectMirror).Type.Name);
2667 // do another invoke
2668 m = t.GetMethod ("invoke_return_void");
2669 v = this_obj.InvokeMethod (e.Thread, m, null);
2672 // Try a single step after the invoke
2673 var req = create_step (e);
2674 req.Depth = StepDepth.Into;
2675 req.Size = StepSize.Line;
2681 // Step into invoke2
2683 e = GetNextEvent ();
2684 Assert.IsTrue (e is StepEvent);
2685 Assert.AreEqual ("invoke2", (e as StepEvent).Method.Name);
2689 frame = e.Thread.GetFrames () [0];
2693 public void Exceptions () {
2694 Event e = run_until ("exceptions");
2695 var req = vm.CreateExceptionRequest (null);
2700 e = GetNextEvent ();
2701 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2702 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2704 var frames = e.Thread.GetFrames ();
2705 Assert.AreEqual ("exceptions", frames [0].Method.Name);
2708 // exception type filter
2710 req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.ArgumentException"));
2713 // Skip the throwing of the second OverflowException
2716 e = GetNextEvent ();
2717 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2718 Assert.AreEqual ("ArgumentException", (e as ExceptionEvent).Exception.Type.Name);
2721 // exception type filter for subclasses
2722 req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.Exception"));
2727 e = GetNextEvent ();
2728 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2729 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2733 req.IncludeSubclasses = false;
2738 e = GetNextEvent ();
2739 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2740 Assert.AreEqual ("Exception", (e as ExceptionEvent).Exception.Type.Name);
2743 // Implicit exceptions
2744 req = vm.CreateExceptionRequest (null);
2749 e = GetNextEvent ();
2750 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2751 Assert.AreEqual ("NullReferenceException", (e as ExceptionEvent).Exception.Type.Name);
2754 // Single stepping after an exception
2755 req = vm.CreateExceptionRequest (null);
2760 e = GetNextEvent ();
2761 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2762 Assert.AreEqual ("Exception", (e as ExceptionEvent).Exception.Type.Name);
2763 frames = e.Thread.GetFrames ();
2764 Assert.AreEqual ("exceptions2", frames [0].Method.Name);
2767 var sreq = create_step (e);
2768 sreq.Depth = StepDepth.Over;
2769 sreq.Size = StepSize.Line;
2773 e = GetNextEvent ();
2774 Assert.IsInstanceOfType (typeof (StepEvent), e);
2775 frames = e.Thread.GetFrames ();
2776 Assert.AreEqual ("exceptions", frames [0].Method.Name);
2779 // Argument checking
2780 AssertThrows<ArgumentException> (delegate {
2781 vm.CreateExceptionRequest (e.Thread.Type);
2786 public void ExceptionFilter () {
2787 Event e = run_until ("exception_filter");
2789 MethodMirror m = entry_point.DeclaringType.GetMethod ("exception_filter_filter");
2790 Assert.IsNotNull (m);
2792 vm.SetBreakpoint (m, 0);
2796 e = GetNextEvent ();
2797 Assert.AreEqual (EventType.Breakpoint, e.EventType);
2798 Assert.IsTrue (e is BreakpointEvent);
2799 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
2801 var frames = e.Thread.GetFrames ();
2803 Assert.IsTrue (frames [0].Location.SourceFile.IndexOf ("dtest-app.cs") != -1);
2804 Assert.AreEqual ("exception_filter_filter", frames [0].Location.Method.Name);
2806 Assert.AreEqual (0, frames [1].Location.Method.MetadataToken);
2807 Assert.AreEqual (0x0f, frames [1].Location.ILOffset);
2809 Assert.AreEqual ("exception_filter_method", frames [2].Location.Method.Name);
2810 Assert.AreEqual (0x06, frames [2].Location.ILOffset);
2812 Assert.AreEqual (0, frames [3].Location.Method.MetadataToken, 0);
2813 Assert.AreEqual (0, frames [3].Location.ILOffset);
2815 Assert.AreEqual ("exception_filter", frames [4].Location.Method.Name);
2819 public void ExceptionFilter2 () {
2822 Start (new string [] { "dtest-excfilter.exe" });
2824 MethodMirror filter_method = entry_point.DeclaringType.GetMethod ("Filter");
2825 Assert.IsNotNull (filter_method);
2827 MethodMirror test_method = entry_point.DeclaringType.GetMethod ("Test");
2828 Assert.IsNotNull (test_method);
2830 vm.SetBreakpoint (filter_method, 0);
2834 var e = GetNextEvent ();
2835 Assert.AreEqual (EventType.Breakpoint, e.EventType);
2836 Assert.IsTrue (e is BreakpointEvent);
2837 Assert.AreEqual (filter_method.Name, (e as BreakpointEvent).Method.Name);
2839 var frames = e.Thread.GetFrames ();
2841 Assert.AreEqual (4, frames.Count ());
2843 Assert.AreEqual (filter_method.Name, frames [0].Location.Method.Name);
2844 Assert.AreEqual (20, frames [0].Location.LineNumber);
2845 Assert.AreEqual (0, frames [0].Location.ILOffset);
2847 Assert.AreEqual (test_method.Name, frames [1].Location.Method.Name);
2848 Assert.AreEqual (37, frames [1].Location.LineNumber);
2849 Assert.AreEqual (0x0b, frames [1].Location.ILOffset);
2851 Assert.AreEqual (test_method.Name, frames [2].Location.Method.Name);
2852 Assert.AreEqual (33, frames [2].Location.LineNumber);
2853 Assert.AreEqual (0x05, frames [2].Location.ILOffset);
2855 Assert.AreEqual (entry_point.Name, frames [3].Location.Method.Name);
2856 Assert.AreEqual (14, frames [3].Location.LineNumber);
2857 Assert.AreEqual (0x00, frames [3].Location.ILOffset);
2865 public void EventSets () {
2867 // Create two filter which both match the same exception
2869 Event e = run_until ("exceptions");
2871 var req = vm.CreateExceptionRequest (null);
2874 var req2 = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.OverflowException"));
2879 var es = vm.GetNextEventSet ();
2880 Assert.AreEqual (2, es.Events.Length);
2883 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2884 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2887 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2888 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2895 // Test single threaded invokes during processing of nullref exceptions.
2896 // These won't work if the exception handling is done from the sigsegv signal
2897 // handler, since the sigsegv signal is disabled until control returns from the
2901 [Category ("only3")]
2902 public void NullRefExceptionAndSingleThreadedInvoke () {
2903 Event e = run_until ("exceptions");
2904 var req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.NullReferenceException"));
2909 e = GetNextEvent ();
2910 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2911 Assert.AreEqual ("NullReferenceException", (e as ExceptionEvent).Exception.Type.Name);
2913 var ex = (e as ExceptionEvent).Exception;
2914 var tostring_method = vm.RootDomain.Corlib.GetType ("System.Object").GetMethod ("ToString");
2915 ex.InvokeMethod (e.Thread, tostring_method, null, InvokeOptions.SingleThreaded);
2919 public void Domains () {
2922 Start (new string [] { "dtest-app.exe", "domain-test" });
2924 vm.EnableEvents (EventType.AppDomainCreate, EventType.AppDomainUnload, EventType.AssemblyUnload);
2926 Event e = run_until ("domains");
2930 e = GetNextEvent ();
2931 Assert.IsInstanceOfType (typeof (AppDomainCreateEvent), e);
2933 var domain = (e as AppDomainCreateEvent).Domain;
2935 // Check the object type
2936 e = run_until ("domains_2");
2937 var frame = e.Thread.GetFrames ()[0];
2938 var o = frame.GetArgument (0) as ObjectMirror;
2939 Assert.AreEqual ("CrossDomain", o.Type.Name);
2941 // Do a remoting invoke
2942 var cross_domain_type = o.Type;
2943 var v = o.InvokeMethod (e.Thread, cross_domain_type.GetMethod ("invoke_3"), null);
2944 AssertValue (42, v);
2946 // Run until the callback in the domain
2947 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke_in_domain");
2948 Assert.IsNotNull (m);
2949 vm.SetBreakpoint (m, 0);
2953 e = GetNextEvent ();
2954 if (e is BreakpointEvent)
2958 Assert.AreEqual ("invoke_in_domain", (e as BreakpointEvent).Method.Name);
2960 // d_method is from another domain
2961 MethodMirror d_method = (e as BreakpointEvent).Method;
2962 Assert.IsTrue (m != d_method);
2964 var frames = e.Thread.GetFrames ();
2965 Assert.AreEqual ("invoke_in_domain", frames [0].Method.Name);
2966 Assert.AreEqual (domain, frames [0].Domain);
2967 Assert.AreEqual ("invoke", frames [1].Method.Name);
2968 Assert.AreEqual ("domains", frames [2].Method.Name);
2969 Assert.AreEqual (vm.RootDomain, frames [2].Domain);
2971 // Test breakpoints on already JITted methods in other domains
2972 m = entry_point.DeclaringType.GetMethod ("invoke_in_domain_2");
2973 Assert.IsNotNull (m);
2974 vm.SetBreakpoint (m, 0);
2978 e = GetNextEvent ();
2979 if (e is BreakpointEvent)
2983 Assert.AreEqual ("invoke_in_domain_2", (e as BreakpointEvent).Method.Name);
2985 // This is empty when receiving the AppDomainCreateEvent
2986 Assert.AreEqual ("domain", domain.FriendlyName);
2988 // Run until the unload
2991 e = GetNextEvent ();
2992 if (e is AssemblyUnloadEvent) {
2998 Assert.IsInstanceOfType (typeof (AppDomainUnloadEvent), e);
2999 Assert.AreEqual (domain, (e as AppDomainUnloadEvent).Domain);
3001 // Run past the unload
3002 e = run_until ("domains_3");
3004 // Test access to unloaded types
3005 // FIXME: Add an exception type for this
3006 AssertThrows<Exception> (delegate {
3007 d_method.DeclaringType.GetValue (d_method.DeclaringType.GetField ("static_i"));
3010 // Check that .Domain is accessible for stack frames with native transitions
3011 e = run_until ("called_from_invoke");
3012 ThreadMirror.NativeTransitions = true;
3013 foreach (var f in e.Thread.GetFrames ()) {
3019 public void DynamicMethods () {
3020 Event e = run_until ("dyn_call");
3022 var m = e.Thread.GetFrames ()[1].Method;
3023 Assert.AreEqual ("dyn_method", m.Name);
3025 // Test access to IL
3026 var body = m.GetMethodBody ();
3028 ILInstruction ins = body.Instructions [0];
3029 Assert.AreEqual (OpCodes.Ldstr, ins.OpCode);
3030 Assert.AreEqual ("FOO", ins.Operand);
3034 public void RefEmit () {
3037 Start (new string [] { "dtest-app.exe", "ref-emit-test" });
3039 Event e = run_until ("ref_emit_call");
3041 var m = e.Thread.GetFrames ()[1].Method;
3042 Assert.AreEqual ("ref_emit_method", m.Name);
3044 // Test access to IL
3045 var body = m.GetMethodBody ();
3049 ins = body.Instructions [0];
3050 Assert.AreEqual (OpCodes.Ldstr, ins.OpCode);
3051 Assert.AreEqual ("FOO", ins.Operand);
3053 ins = body.Instructions [1];
3054 Assert.AreEqual (OpCodes.Call, ins.OpCode);
3055 Assert.IsInstanceOfType (typeof (MethodMirror), ins.Operand);
3056 Assert.AreEqual ("ref_emit_call", (ins.Operand as MethodMirror).Name);
3060 public void IsAttached () {
3061 var f = entry_point.DeclaringType.GetField ("is_attached");
3063 Event e = run_until ("Main");
3065 AssertValue (true, entry_point.DeclaringType.GetValue (f));
3069 public void StackTraceInNative () {
3070 // Check that stack traces can be produced for threads in native code
3073 Start (new string [] { "dtest-app.exe", "frames-in-native" });
3075 var e = run_until ("frames_in_native");
3077 // FIXME: This is racy
3084 StackFrame[] frames = e.Thread.GetFrames ();
3086 int frame_index = -1;
3087 for (int i = 0; i < frames.Length; ++i) {
3088 if (frames [i].Method.Name == "Sleep") {
3094 Assert.IsTrue (frame_index != -1);
3095 Assert.AreEqual ("Sleep", frames [frame_index].Method.Name);
3096 Assert.AreEqual ("frames_in_native", frames [frame_index + 1].Method.Name);
3097 Assert.AreEqual ("Main", frames [frame_index + 2].Method.Name);
3099 // Check that invokes are disabled for such threads
3100 TypeMirror t = frames [frame_index + 1].Method.DeclaringType;
3102 var m = t.GetMethod ("invoke_static_return_void");
3103 AssertThrows<InvalidOperationException> (delegate {
3104 t.InvokeMethod (e.Thread, m, null);
3107 // Check that the frame info is invalidated
3108 run_until ("frames_in_native_2");
3110 AssertThrows<InvalidStackFrameException> (delegate {
3111 Console.WriteLine (frames [frame_index].GetThis ());
3116 public void VirtualMachine_CreateEnumMirror () {
3117 var e = run_until ("o1");
3118 var frame = e.Thread.GetFrames () [0];
3120 object val = frame.GetThis ();
3121 Assert.IsTrue (val is ObjectMirror);
3122 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
3123 ObjectMirror o = (val as ObjectMirror);
3125 FieldInfoMirror field = o.Type.GetField ("field_enum");
3126 Value f = o.GetValue (field);
3127 TypeMirror enumType = (f as EnumMirror).Type;
3129 o.SetValue (field, vm.CreateEnumMirror (enumType, vm.CreateValue (1)));
3130 f = o.GetValue (field);
3131 Assert.AreEqual (1, (f as EnumMirror).Value);
3133 // Argument checking
3134 AssertThrows<ArgumentNullException> (delegate () {
3135 vm.CreateEnumMirror (enumType, null);
3138 AssertThrows<ArgumentNullException> (delegate () {
3139 vm.CreateEnumMirror (null, vm.CreateValue (1));
3143 AssertThrows<ArgumentException> (delegate () {
3144 vm.CreateEnumMirror (enumType, vm.CreateValue (null));
3147 // value of a wrong type
3148 AssertThrows<ArgumentException> (delegate () {
3149 vm.CreateEnumMirror (enumType, vm.CreateValue ((long)1));
3154 public void VirtualMachine_EnableEvents_Breakpoint () {
3155 AssertThrows<ArgumentException> (delegate () {
3156 vm.EnableEvents (EventType.Breakpoint);
3161 public void SingleStepRegress654694 () {
3164 MethodMirror m = entry_point.DeclaringType.GetMethod ("ss_regress_654694");
3165 foreach (Location l in m.Locations) {
3166 if (l.ILOffset > 0 && il_offset == -1)
3167 il_offset = l.ILOffset;
3170 Event e = run_until ("ss_regress_654694");
3172 Assert.IsNotNull (m);
3173 vm.SetBreakpoint (m, il_offset);
3177 e = GetNextEvent ();
3178 Assert.IsTrue (e is BreakpointEvent);
3180 var req = create_step (e);
3181 req.Depth = StepDepth.Over;
3182 req.Size = StepSize.Line;
3187 e = GetNextEvent ();
3188 Assert.IsTrue (e is StepEvent);
3194 public void DebugBreak () {
3195 vm.EnableEvents (EventType.UserBreak);
3200 var e = GetNextEvent ();
3201 Assert.IsTrue (e is UserBreakEvent);
3205 public void DebugLog () {
3206 vm.EnableEvents (EventType.UserLog);
3211 var e = GetNextEvent ();
3212 Assert.IsTrue (e is UserLogEvent);
3213 var le = e as UserLogEvent;
3215 Assert.AreEqual (5, le.Level);
3216 Assert.AreEqual ("A", le.Category);
3217 Assert.AreEqual ("B", le.Message);
3221 public void TypeGetMethodsByNameFlags () {
3223 var assembly = entry_point.DeclaringType.Assembly;
3224 var type = assembly.GetType ("Tests3");
3226 Assert.IsNotNull (type);
3228 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.Public, false);
3229 Assert.AreEqual (1, mm.Length, "#1");
3230 Assert.AreEqual ("M1", mm[0].Name, "#2");
3232 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.NonPublic, false);
3233 Assert.AreEqual (1, mm.Length, "#3");
3234 Assert.AreEqual ("M2", mm[0].Name, "#4");
3236 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.Public, false);
3237 Assert.AreEqual (7, mm.Length, "#5"); //M3 plus Equals, GetHashCode, GetType, ToString, .ctor
3239 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly, false);
3240 Assert.AreEqual (2, mm.Length, "#7");
3242 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly, false);
3243 Assert.AreEqual (1, mm.Length, "#9");
3245 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly, false);
3246 Assert.AreEqual (5, mm.Length, "#11");
3249 mm = type.GetMethodsByNameFlags ("M1", BindingFlags.Static | BindingFlags.Public, false);
3250 Assert.AreEqual (1, mm.Length, "#12");
3251 Assert.AreEqual ("M1", mm[0].Name, "#13");
3253 mm = type.GetMethodsByNameFlags ("m1", BindingFlags.Static | BindingFlags.Public, true);
3254 Assert.AreEqual (1, mm.Length, "#14");
3255 Assert.AreEqual ("M1", mm[0].Name, "#15");
3257 mm = type.GetMethodsByNameFlags ("M1", BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, false);
3258 Assert.AreEqual (1, mm.Length, "#16");
3259 Assert.AreEqual ("M1", mm[0].Name, "#17");
3263 [Category ("only88")]
3264 public void TypeLoadSourceFileFilter () {
3265 Event e = run_until ("type_load");
3267 if (!vm.Version.AtLeast (2, 7))
3270 string srcfile = (e as BreakpointEvent).Method.DeclaringType.GetSourceFiles (true)[0];
3272 var req = vm.CreateTypeLoadRequest ();
3273 req.SourceFileFilter = new string [] { srcfile.ToUpper () };
3277 e = GetNextEvent ();
3278 Assert.IsTrue (e is TypeLoadEvent);
3279 Assert.AreEqual ("TypeLoadClass", (e as TypeLoadEvent).Type.FullName);
3283 public void TypeLoadTypeNameFilter () {
3284 Event e = run_until ("type_load");
3286 var req = vm.CreateTypeLoadRequest ();
3287 req.TypeNameFilter = new string [] { "TypeLoadClass2" };
3291 e = GetNextEvent ();
3292 Assert.IsTrue (e is TypeLoadEvent);
3293 Assert.AreEqual ("TypeLoadClass2", (e as TypeLoadEvent).Type.FullName);
3297 public void GetTypesForSourceFile () {
3300 var types = vm.GetTypesForSourceFile ("dtest-app.cs", false);
3301 Assert.IsTrue (types.Any (t => t.FullName == "Tests"));
3302 Assert.IsFalse (types.Any (t => t.FullName == "System.Int32"));
3304 types = vm.GetTypesForSourceFile ("DTEST-app.cs", true);
3305 Assert.IsTrue (types.Any (t => t.FullName == "Tests"));
3306 Assert.IsFalse (types.Any (t => t.FullName == "System.Int32"));
3310 public void GetTypesNamed () {
3313 var types = vm.GetTypes ("Tests", false);
3314 Assert.AreEqual (1, types.Count);
3315 Assert.AreEqual ("Tests", types [0].FullName);
3317 types = vm.GetTypes ("System.Exception", false);
3318 Assert.AreEqual (1, types.Count);
3319 Assert.AreEqual ("System.Exception", types [0].FullName);
3323 public void String_GetChars () {
3327 var e = run_until ("arg2");
3329 var frame = e.Thread.GetFrames () [0];
3331 val = frame.GetArgument (0);
3332 Assert.IsTrue (val is StringMirror);
3333 AssertValue ("FOO", val);
3334 var s = (val as StringMirror);
3335 Assert.AreEqual (3, s.Length);
3337 var c = s.GetChars (0, 2);
3338 Assert.AreEqual (2, c.Length);
3339 Assert.AreEqual ('F', c [0]);
3340 Assert.AreEqual ('O', c [1]);
3342 AssertThrows<ArgumentException> (delegate () {
3348 public void GetInterfaces () {
3349 var e = run_until ("arg2");
3351 var frame = e.Thread.GetFrames () [0];
3353 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("TestIfaces");
3354 var ifaces = cl1.GetInterfaces ();
3355 Assert.AreEqual (1, ifaces.Length);
3356 Assert.AreEqual ("ITest", ifaces [0].Name);
3358 var cl2 = cl1.GetMethod ("Baz").ReturnType;
3359 var ifaces2 = cl2.GetInterfaces ();
3360 Assert.AreEqual (1, ifaces2.Length);
3361 Assert.AreEqual ("ITest`1", ifaces2 [0].Name);
3365 public void GetInterfaceMap () {
3366 var e = run_until ("arg2");
3368 var frame = e.Thread.GetFrames () [0];
3370 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("TestIfaces");
3371 var iface = cl1.Assembly.GetType ("ITest");
3372 var map = cl1.GetInterfaceMap (iface);
3373 Assert.AreEqual (cl1, map.TargetType);
3374 Assert.AreEqual (iface, map.InterfaceType);
3375 Assert.AreEqual (2, map.InterfaceMethods.Length);
3376 Assert.AreEqual (2, map.TargetMethods.Length);
3380 public void StackAlloc_Breakpoints_Regress2775 () {
3381 // Check that breakpoints on arm don't overwrite stackalloc-ed memory
3382 var e = run_until ("regress_2755");
3384 var frame = e.Thread.GetFrames () [0];
3386 // This breaks at the call site
3387 vm.SetBreakpoint (m, m.Locations [2].ILOffset);
3390 var e2 = GetNextEvent ();
3391 Assert.IsTrue (e2 is BreakpointEvent);
3393 e = run_until ("regress_2755_3");
3394 frame = e.Thread.GetFrames () [1];
3395 var res = frame.GetValue (m.GetLocal ("sum"));
3396 AssertValue (0, res);
3400 public void MethodInfo () {
3401 Event e = run_until ("locals2");
3403 StackFrame frame = e.Thread.GetFrames () [0];
3404 var m = frame.Method;
3406 Assert.IsTrue (m.IsGenericMethod);
3407 Assert.IsFalse (m.IsGenericMethodDefinition);
3409 var args = m.GetGenericArguments ();
3410 Assert.AreEqual (1, args.Length);
3411 Assert.AreEqual ("String", args [0].Name);
3413 var gmd = m.GetGenericMethodDefinition ();
3414 Assert.IsTrue (gmd.IsGenericMethod);
3415 Assert.IsTrue (gmd.IsGenericMethodDefinition);
3416 Assert.AreEqual (gmd, gmd.GetGenericMethodDefinition ());
3418 args = gmd.GetGenericArguments ();
3419 Assert.AreEqual (1, args.Length);
3420 Assert.AreEqual ("T", args [0].Name);
3422 var attrs = m.GetCustomAttributes (true);
3423 Assert.AreEqual (1, attrs.Length);
3424 Assert.AreEqual ("StateMachineAttribute", attrs [0].Constructor.DeclaringType.Name);
3428 public void UnhandledException () {
3431 Start (new string [] { "dtest-app.exe", "unhandled-exception" });
3433 var req = vm.CreateExceptionRequest (null, false, true);
3436 var e = run_until ("unhandled_exception");
3439 var e2 = GetNextEvent ();
3440 Assert.IsTrue (e2 is ExceptionEvent);
3447 public void UnhandledException_2 () {
3450 Start (new string [] { "dtest-app.exe", "unhandled-exception-endinvoke" });
3452 var req = vm.CreateExceptionRequest (null, false, true);
3455 MethodMirror m = entry_point.DeclaringType.GetMethod ("unhandled_exception_endinvoke_2");
3456 Assert.IsNotNull (m);
3457 vm.SetBreakpoint (m, m.ILOffsets [0]);
3459 var e = run_until ("unhandled_exception_endinvoke");
3462 var e2 = GetNextEvent ();
3463 Assert.IsFalse (e2 is ExceptionEvent);
3471 public void UnhandledExceptionUserCode () {
3474 // Exceptions caught in non-user code are treated as unhandled
3475 Start (new string [] { "dtest-app.exe", "unhandled-exception-user" });
3477 var req = vm.CreateExceptionRequest (null, false, true);
3478 req.AssemblyFilter = new List<AssemblyMirror> () { entry_point.DeclaringType.Assembly };
3481 var e = run_until ("unhandled_exception_user");
3484 var e2 = GetNextEvent ();
3485 Assert.IsTrue (e2 is ExceptionEvent);
3493 public void GCWhileSuspended () {
3494 // Check that objects are kept alive during suspensions
3495 Event e = run_until ("gc_suspend_1");
3497 MethodMirror m = entry_point.DeclaringType.GetMethod ("gc_suspend_invoke");
3499 var o = entry_point.DeclaringType.GetValue (entry_point.DeclaringType.GetField ("gc_suspend_field")) as ObjectMirror;
3500 //Console.WriteLine (o);
3502 StackFrame frame = e.Thread.GetFrames () [0];
3503 TypeMirror t = frame.Method.DeclaringType;
3504 for (int i = 0; i < 10; ++i)
3505 t.InvokeMethod (e.Thread, m, new Value [] { });
3507 // This throws an exception if the object is collected
3508 long addr = o.Address;
3510 var o2 = entry_point.DeclaringType.GetValue (entry_point.DeclaringType.GetField ("gc_suspend_field")) as ObjectMirror;
3515 public void MakeGenericMethod () {
3516 Event e = run_until ("bp1");
3518 var intm = vm.RootDomain.GetCorrespondingType (typeof (int));
3519 var stringm = vm.RootDomain.GetCorrespondingType (typeof (string));
3520 var gm = entry_point.DeclaringType.GetMethod ("generic_method");
3521 var res = gm.MakeGenericMethod (new TypeMirror [] { stringm });
3522 var args = res.GetGenericArguments ();
3523 Assert.AreEqual (1, args.Length);
3524 Assert.AreEqual (stringm, args [0]);
3527 AssertThrows<ArgumentNullException> (delegate {
3528 gm.MakeGenericMethod (null);
3530 AssertThrows<ArgumentNullException> (delegate {
3531 gm.MakeGenericMethod (new TypeMirror [] { null });
3533 AssertThrows<ArgumentException> (delegate {
3534 gm.MakeGenericMethod (new TypeMirror [] { stringm, stringm });
3536 AssertThrows<InvalidOperationException> (delegate {
3537 gm.MakeGenericMethod (new TypeMirror [] { intm });
3539 AssertThrows<InvalidOperationException> (delegate {
3540 entry_point.DeclaringType.GetMethod ("Main").MakeGenericMethod (new TypeMirror [] { intm });
3545 public void InspectThreadSuspenedOnWaitOne () {
3547 Start (true, "dtest-app.exe", "wait-one" );
3549 ThreadMirror.NativeTransitions = true;
3551 var evt = run_until ("wait_one");
3552 Assert.IsNotNull (evt, "#1");
3554 var thread = evt.Thread;
3555 Assert.AreEqual (ThreadState.Running, thread.ThreadState, "#1.1");
3557 var frames = thread.GetFrames ();
3558 Assert.IsNotNull (frames, "#2");
3559 Assert.AreEqual (2, frames.Length, "#3");
3560 Assert.AreEqual ("wait_one", frames [0].Method.Name, "#4");
3561 Assert.AreEqual ("Main", frames [1].Method.Name, "#5");
3565 Thread.Sleep (500); //FIXME this is racy, maybe single step? or something?
3568 Assert.AreEqual (ThreadState.WaitSleepJoin, thread.ThreadState, "#6");
3570 frames = thread.GetFrames ();
3571 Assert.AreEqual (4, frames.Length, "#7");
3572 Assert.AreEqual ("WaitOne_internal", frames [0].Method.Name, "#8");
3573 Assert.AreEqual ("WaitOne", frames [1].Method.Name, "#8.1");
3574 Assert.AreEqual ("wait_one", frames [2].Method.Name, "#9");
3575 Assert.AreEqual ("Main", frames [3].Method.Name, "#10");
3578 var frame = frames [0];
3579 Assert.IsTrue (frame.IsNativeTransition, "#11.1");
3582 Assert.Fail ("Known limitation - can't get info from m2n frames");
3583 } catch (AbsentInformationException) {}
3586 Assert.IsFalse (frame.IsNativeTransition, "#12.1");
3587 var wait_one_this = frame.GetThis ();
3588 Assert.IsNotNull (wait_one_this, "#12.2");
3591 var locals = frame.GetVisibleVariables ();
3592 Assert.AreEqual (1, locals.Count, "#13.1");
3594 var local_0 = frame.GetValue (locals [0]);
3595 Assert.IsNotNull (local_0, "#13.2");
3597 Assert.AreEqual (wait_one_this, local_0, "#14.2");
3601 public void GetMethodBody () {
3602 var bevent = run_until ("Main");
3604 var m = bevent.Method.DeclaringType.GetMethod ("get_IntProperty");
3605 var body = m.GetMethodBody ();
3606 foreach (var ins in body.Instructions) {
3607 if (ins.OpCode == OpCodes.Ldfld) {
3608 var field = (FieldInfoMirror)ins.Operand;
3609 Assert.AreEqual ("field_i", field.Name);
3615 public void EvaluateMethod () {
3616 var bevent = run_until ("evaluate_method_2");
3618 var m = bevent.Method.DeclaringType.GetMethod ("get_IntProperty");
3620 var this_obj = bevent.Thread.GetFrames ()[0].GetThis ();
3621 var v = m.Evaluate (this_obj, null);
3622 AssertValue (42, v);
3626 public void SetIP () {
3627 var bevent = run_until ("set_ip_1");
3629 var invalid_loc = bevent.Thread.GetFrames ()[0].Location;
3631 var req = create_step (bevent);
3632 var e = step_out ();
3634 var frames = e.Thread.GetFrames ();
3635 var locs = frames [0].Method.Locations;
3636 var next_loc = locs.First (l => (l.LineNumber == frames [0].Location.LineNumber + 2));
3638 e.Thread.SetIP (next_loc);
3640 /* Check that i ++; j = 5; was skipped */
3641 bevent = run_until ("set_ip_2");
3642 var f = bevent.Thread.GetFrames ()[1];
3643 AssertValue (2, f.GetValue (f.Method.GetLocal ("i")));
3644 AssertValue (0, f.GetValue (f.Method.GetLocal ("j")));
3647 AssertThrows<ArgumentNullException> (delegate {
3648 e.Thread.SetIP (null);
3651 AssertThrows<ArgumentException> (delegate {
3652 e.Thread.SetIP (invalid_loc);
3657 public void SetIPSingleStep () {
3658 // Check that single stepping after set-ip steps from the new ip
3659 var bevent = run_until ("set_ip_1");
3661 var invalid_loc = bevent.Thread.GetFrames ()[0].Location;
3663 var req = create_step (bevent);
3664 req.Size = StepSize.Line;
3665 var e = step_out ();
3667 var frames = e.Thread.GetFrames ();
3668 var locs = frames [0].Method.Locations;
3669 var prev_loc = locs.First (l => (l.LineNumber == frames [0].Location.LineNumber - 3));
3670 AssertValue (2, frames [0].GetValue (frames [0].Method.GetLocal ("i")));
3672 // Set back the ip to the first i ++; line
3673 e.Thread.SetIP (prev_loc);
3676 var f = e.Thread.GetFrames ()[0];
3677 AssertValue (3, f.GetValue (f.Method.GetLocal ("i")));
3681 public void NewInstanceNoCtor () {
3682 var bevent = run_until ("Main");
3684 var stype = bevent.Method.DeclaringType.Assembly.GetType ("AStruct");
3685 var obj = stype.NewInstance ();
3686 Assert.IsTrue (obj is ObjectMirror);
3687 Assert.AreEqual ("AStruct", (obj as ObjectMirror).Type.Name);
3691 public void StaticCtorFilterInCctor () {
3692 // Check that single stepping when in a cctor only ignores
3693 // other cctors, not the current one
3694 var bevent = run_until ("step_filters");
3696 var assembly = entry_point.DeclaringType.Assembly;
3697 var type = assembly.GetType ("Tests/ClassWithCctor");
3698 var cctor = type.GetMethod (".cctor");
3699 vm.SetBreakpoint (cctor, 0);
3702 var e = vm.GetNextEvent ();
3703 Assert.IsTrue (e is BreakpointEvent);
3705 var req = create_step (e);
3706 req.Filter = StepFilter.StaticCtor;
3708 // Make sure we are still in the cctor
3709 Assert.AreEqual (".cctor", e.Thread.GetFrames ()[0].Location.Method.Name);